क्या यह उतना ही खर्च करना सामान्य है, यदि वास्तविक कोड की तुलना में अधिक, समय लेखन परीक्षण नहीं है?


210

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

क्या वह सामान्य है या मैं कुछ गलत कर रहा हूं?

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

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


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

10
आप अपना कोड लिखने से ज्यादा समय पढ़ने में भी लगाते हैं।
थोरबजोरन रावन एंडरसन

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

5
आदर्श रूप से आप अपना कोड लिखने की तुलना में अधिक समय व्यतीत करेंगे। (अन्यथा, आप केवल हाथ से कार्य करेंगे।)
यहोशू टेलर

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

जवाबों:


204

मुझे एक सॉफ्टवेयर इंजीनियरिंग पाठ्यक्रम याद है, जिसमें एक विकास कोड के ~ 10% नए कोड लिखने में खर्च करता है, और दूसरा 90% डिबगिंग, परीक्षण और प्रलेखन है।

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

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

यदि आपके परीक्षणों को लिखना मुश्किल है, तो वे जिस कोड का परीक्षण करते हैं वह संभवतः उपयोग करना कठिन है!


4
यह देखने का एक अच्छा समय हो सकता है कि कोड का परीक्षण करना इतना कठिन क्यों है :) जटिल बहु-फ़ंक्शन लाइनों को "अनियंत्रित" करने की कोशिश करें जो कड़ाई से आवश्यक नहीं हैं, जैसे बड़े पैमाने पर नेस्टेड बाइनरी / टर्नरी ऑपरेटर ... मुझे वास्तव में अनावश्यक बाइनरी से नफरत है / ternary ऑपरेटर जिसमें एक बाइनरी / ternary ऑपरेटर भी है जो पथों में से एक है ...
नेल्सन

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

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

2
@phyrfox मुझे लगता है कि यह बहुत सतर्क है, यह "कोड के अन्य 99% किनारे के मामलों" जैसा है। जिसका अर्थ है कि अन्य 99% परीक्षण उन किनारे के मामलों के लिए हैं।
20

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

96

यह है।

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

एक साधारण कोड पर विचार करें:

public void SayHello(string personName)
{
    if (personName == null) throw new NullArgumentException("personName");

    Console.WriteLine("Hello, {0}!", personName);
}

परीक्षण क्या होंगे? यहाँ परीक्षण करने के लिए कम से कम चार सरल मामले हैं:

  1. व्यक्ति का नाम है null। क्या अपवाद वास्तव में फेंक दिया गया है? लिखने के लिए परीक्षण कोड की कम से कम तीन लाइनें हैं।

  2. व्यक्ति का नाम है "Jeff"। क्या हमें "Hello, Jeff!"जवाब में मिलता है? यह परीक्षण कोड की चार लाइनें हैं।

  3. व्यक्ति का नाम एक खाली स्ट्रिंग है। हम किस आउटपुट की उम्मीद करते हैं? वास्तविक उत्पादन क्या है? साइड सवाल: क्या यह कार्यात्मक आवश्यकताओं से मेल खाता है? इसका मतलब है कि यूनिट टेस्ट के लिए कोड की एक और चार लाइनें।

  4. एक स्ट्रिंग के लिए व्यक्ति का नाम काफी छोटा है, लेकिन बहुत लंबे समय तक "Hello, "और विस्मयादिबोधक बिंदु के साथ जोड़ा जा सकता है । क्या होता है? ¹

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

यदि अनुपात बहुत बड़ा है, तो आप किस मामले में कुछ चीजें देख सकते हैं:

  • क्या परीक्षणों में कोड दोहराव है? तथ्य यह है कि यह परीक्षण कोड है इसका मतलब यह नहीं है कि समान परीक्षणों के बीच कोड को डुप्लिकेट (कॉपी-पेस्ट) किया जाना चाहिए: ऐसे दोहराव से उन परीक्षणों का रखरखाव मुश्किल हो जाएगा।

  • क्या निरर्थक परीक्षण हैं? अंगूठे के एक नियम के रूप में, यदि आप एक इकाई परीक्षण निकालते हैं, तो शाखा कवरेज घटनी चाहिए। यदि ऐसा नहीं होता है, तो यह संकेत दे सकता है कि परीक्षण की आवश्यकता नहीं है, क्योंकि रास्ते पहले से ही अन्य परीक्षणों द्वारा कवर किए गए हैं।

  • क्या आप केवल उस कोड का परीक्षण कर रहे हैं जिसे आपको परीक्षण करना चाहिए? आपको तीसरे पक्ष के पुस्तकालयों के अंतर्निहित ढांचे का परीक्षण करने की उम्मीद नहीं है , लेकिन विशेष रूप से परियोजना का कोड ही है।

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

TDD के बारे में एक नोट

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


¹ चलो n होना एक स्ट्रिंग की अधिकतम लंबाई । हम कॉल कर सकते हैं SayHelloऔर संदर्भ के माध्यम से पास कर सकते हैं लंबाई n - 1 जो ठीक काम करना चाहिए। अब, Console.WriteLineकदम पर, स्वरूपण लंबाई n + 8 की एक स्ट्रिंग के साथ समाप्त होना चाहिए , जिसके परिणामस्वरूप एक अपवाद होगा। संभवतः, स्मृति सीमाओं के कारण, यहां तक ​​कि n / 2 वर्णों वाली स्ट्रिंग भी अपवाद को जन्म देगी। एक प्रश्न यह पूछना चाहिए कि क्या यह चौथा परीक्षण एक इकाई परीक्षण है (यह एक जैसा दिखता है, लेकिन औसत इकाई परीक्षणों की तुलना में संसाधनों के संदर्भ में बहुत अधिक प्रभाव हो सकता है) और यदि यह वास्तविक कोड या अंतर्निहित ढांचे का परीक्षण करता है।


5
मत भूलना एक व्यक्ति का नाम नल भी हो सकता है। stackoverflow.com/questions/4456438/…
psatek

1
@JacobRaihle मेरा मानना ​​है कि @MainMa का अर्थ है personNameफिट बैठता है एक में string, लेकिन personNameप्लस के मान को अतिप्रवाहित मान string
woz

@JacobRaihle: मैंने इस बिंदु को समझाने के लिए अपना उत्तर संपादित किया। फुटनोट देखें।
आर्सेनी मूरज़ेंको

4
As a rule of thumb, if you remove a unit test, the branch coverage should decrease.यदि मैं आपके द्वारा उल्लिखित सभी चार परीक्षणों को लिखता हूं, और फिर तीसरे परीक्षण को हटा दें, तो क्या कवरेज कम हो जाएगी?
विवेक

3
"लंबे समय तक" → "बहुत लंबा" (बिंदु 4 में)?
पाओलो एबरमन

59

मुझे लगता है कि दो प्रकार की परीक्षण रणनीतियों के बीच अंतर करना महत्वपूर्ण है: इकाई परीक्षण और एकीकरण / स्वीकृति परीक्षण।

यद्यपि कुछ मामलों में यूनिट परीक्षण आवश्यक है, लेकिन यह अक्सर निराशाजनक रूप से अधिक हो जाता है। यह डेवलपर्स पर मजबूर अर्थहीनता से बढ़ा है, जैसे "100% कवरेज"। http://www.rbcs-us.com/documents/Why-Most-Unit-Testing-is-Waste.pdf इसके लिए एक सम्मोहक तर्क प्रदान करता है। आक्रामक इकाई परीक्षण के साथ निम्नलिखित मुद्दों पर विचार करें:

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

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

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


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

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

3
मैं आपको तब तक खुश कर रहा हूं जब तक " .equals()ग्रहण द्वारा उत्पन्न उन लंबी विधियों का परीक्षण करने की कोई आवश्यकता नहीं है ।" मैंने github.com/GlenKPeterson/TestUtils के लिए एक टेस्ट हार्नेस लिखा equals()और लगभग हर कार्यान्वयन जिसे मैंने कभी भी परीक्षण किया है, उसमें कमी थी। यदि आप संग्रह का उपयोग कैसे करते हैं और यदि सही और कुशलता से एक साथ काम नहीं करते हैं? मैं आपके उत्तर के लिए फिर से खुश हूँ और इसे अप-वोट किया है। मैं यह भी अनुदान देता हूं कि कुछ ऑटो-जनरेटेड इक्वल्स () विधियों को परीक्षण की आवश्यकता नहीं हो सकती है , लेकिन मेरे पास खराब कार्यान्वयन के साथ इतने सारे कीड़े हैं कि यह मुझे परेशान करता है। compareTo() equals()hashCode()
GlenPeterson

1
@GlenPeterson सहमत हैं। मेरे एक सहयोगी ने इस उद्देश्य के लिए EqualsVerifier लिखा। देखिए github.com/jqno/equalsverifier
Tohnmeister

@ Cept नहीं, आपको अभी भी अस्वीकार्य इनपुट का परीक्षण करना है, यही कारण है कि लोगों को सुरक्षा कारनामे कैसे मिलते हैं।
gbjbaanb 13

11

सामान्यीकृत नहीं किया जा सकता है।

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

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


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

3

यदि आप TDDing के बारे में बात कर रहे हैं, तो यह सामान्य है। जब आपके पास स्वचालित परीक्षण होते हैं, तो आप अपने कोड के वांछित व्यवहार को सुरक्षित करते हैं। जब आप पहले अपने परीक्षण लिखते हैं, तो आप यह निर्धारित करते हैं कि मौजूदा कोड में पहले से ही वह व्यवहार है जो आप चाहते हैं।

इस का मतलब है कि:

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

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

हां, यदि आप इस तथ्य के बाद परीक्षण लिखने की बात कर रहे हैं, तो आप अधिक समय व्यतीत करेंगे:

  • इच्छित व्यवहार का निर्धारण।
  • वांछित व्यवहार का परीक्षण करने के तरीके का निर्धारण।
  • परीक्षण लिखने में सक्षम होने के लिए कोड निर्भरता को पूरा करना।
  • परीक्षणों के लिए सही कोड जो विफल हो जाते हैं।

वास्तव में आप कोड लिखने में खर्च करेंगे।

तो हाँ, यह एक अपेक्षित उपाय है।


3

मुझे यह सबसे महत्वपूर्ण हिस्सा लगता है।

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

यही कारण है कि इस पृष्ठ पर अन्य उत्तरों में से एक का उल्लेख है कि "पाठ्यक्रम" में उन्होंने 90% परीक्षण किया, क्योंकि हर किसी को अपने उद्देश्य के बारे में जानने की जरूरत थी।

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


2

यह कई लोगों के लिए हो सकता है, लेकिन यह निर्भर करता है।

यदि आप पहले परीक्षण (टीडीडी) लिख रहे हैं, तो हो सकता है कि आपको समय के साथ कुछ ओवरलैप का सामना करना पड़ रहा हो। विचार करें:

  • परिणाम और इनपुट (पैरामीटर) का निर्धारण
  • नामकरण की परंपरा
  • संरचना - चीजों को कहां रखा जाए।
  • पुरानी सोच है

कोड लिखने के बाद परीक्षण लिखते समय, आपको पता चल सकता है कि आपका कोड आसानी से परीक्षण योग्य नहीं है, इसलिए परीक्षण लिखना कठिन है / अधिक समय लेता है।

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

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

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


2

क्या यह उतना ही खर्च करना सामान्य है, यदि वास्तविक कोड की तुलना में अधिक, समय लेखन परीक्षण नहीं है?

हाँ यही है। कुछ कैविएट के साथ।

सबसे पहले, यह इस अर्थ में "सामान्य" है कि ज्यादातर बड़ी दुकानें इस तरह से काम करती हैं, इसलिए भले ही यह तरीका पूरी तरह से गलत और गूंगा था, फिर भी, इस तथ्य से कि ज्यादातर बड़ी दुकानें इस तरह से काम करती हैं, यह "सामान्य" है।

इससे मेरा तात्पर्य यह नहीं है कि इसका परीक्षण गलत है। मैंने बिना परीक्षण वाले वातावरण में काम किया है, और जुनूनी-बाध्यकारी परीक्षण के साथ वातावरण में, और मैं अभी भी आपको बता सकता हूं कि जुनूनी-बाध्यकारी परीक्षण बिना परीक्षण के बेहतर था।

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

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

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


0

क्या यह उतना ही खर्च करना सामान्य है, यदि वास्तविक कोड की तुलना में अधिक, समय लेखन परीक्षण नहीं है?

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