इकाई परीक्षणों का उपयोग करते हुए किसी एनम के मूल्यों का परीक्षण करना चाहिए?


15

यदि आपके पास केवल मानों के साथ एक एनम है (जावा में कोई भी तरीका नहीं कर सकता है), और यह एनम सिस्टम की व्यावसायिक परिभाषा का हिस्सा है, तो क्या किसी को इसके लिए यूनिट टेस्ट लिखना चाहिए?

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

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

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


19
वास्तव में एक एनुम की इकाई परीक्षण कैसा दिखेगा?
जॉन्सर्शपे


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

1
@jonrsharpe, मुझे यूनिट परीक्षणों को "परिभाषाओं" या "आवश्यकताओं" के रूप में भी कोड में लिखना पसंद है। एनम का एक इकाई परीक्षण, एनम और उनके मूल्यों पर मदों की संख्या की जाँच करने के रूप में सरल होगा। विशेष रूप से सी # में, जहां एनम वर्ग नहीं हैं, लेकिन सीधे पूर्णांकों के लिए मैप किया जा सकता है, उनके मूल्यों की गारंटी देना और संयोग से प्रोग्रामिंग नहीं करना क्रमिक उद्देश्यों के लिए उपयोगी साबित हो सकता है।
मचादो

2
यदि IME सही है, तो यह जाँचने के लिए IMHO यह 2 + 2 = 4 के परीक्षण से अधिक उपयोगी नहीं है। आप उस एनम का उपयोग करके कोड का परीक्षण करते हैं, एनम का ही नहीं।
Agent_L

जवाबों:


39

यदि आपके पास केवल मानों के साथ एक एनम है (जावा में कोई भी तरीका नहीं कर सकता है), और यह एनम सिस्टम की व्यावसायिक परिभाषा का हिस्सा है, तो क्या किसी को इसके लिए यूनिट टेस्ट लिखना चाहिए?

नहीं, वे सिर्फ राज्य हैं।

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

पूर्णता के लिए परीक्षण enums परीक्षण के अनुरूप है कि सभी प्रतिनिधित्व योग्य पूर्णांक मौजूद हैं।

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


5
लेकिन इस मामले में कार्यान्वयन विवरण डेटा की "वास्तविक प्रकृति" के साथ मेल खाता है, जो है: मूल्यों का एक सेट (गणितीय अर्थ में)। आप यकीनन एक अपरिवर्तनीय सेट का उपयोग कर सकते हैं, लेकिन वही मूल्य अभी भी वहां मौजूद होना चाहिए। यदि आप किसी सरणी का उपयोग करते हैं, तो व्यापार तर्क का परीक्षण करने के लिए एक ही चीज़ होनी चाहिए। मुझे लगता है कि इस तथ्य को यहां बताया गया है कि भाषा का निर्माण आंकड़ों की प्रकृति के साथ बहुत अच्छी तरह से मेल खाता है। मुझे यकीन नहीं है कि मैंने खुद को सही तरीके से समझाया है।
IS1_SO

4
@ IS1_SO - VOU के बिंदु पर कि एक परीक्षण हालांकि विफल होना चाहिए: क्या यह हुआ? किस मामले में, आपको विशेष रूप से Enum का परीक्षण करने की आवश्यकता नहीं थी। यह नहीं किया? हो सकता है कि एक संकेत है कि आप अपने कोड अधिक बस मॉडल और डेटा की 'वास्तविक स्वरूप' पर एक अमूर्त बना सकते है कि - जैसे एक डेक में कार्ड की परवाह किए बिना तुम सच का एक प्रतिनिधित्व करने की आवश्यकता है, [ Hearts, Spades, Diamonds, Clubs] अगर यदि आप एक कार्ड लाल / काला है तो आप केवल कभी कार्ड?
दूसरा सेप 27'17

1
@ IS1_SO आपको त्रुटि कोड की एक सूचना देता है, और आप एक null_ptrत्रुटि फेंकना चाहते हैं । अब एनम के माध्यम से एक त्रुटि कोड है। किसी null_ptrत्रुटि के लिए कोड की जाँच करने वाला कोड को एनम के माध्यम से भी देखता है। तो इसका मान हो सकता है 5(पूर्व के लिए)। अब आपको एक और एरर कोड जोड़ना होगा। एनम बदल दिया गया है (मान लें कि हम एनम के शीर्ष पर एक नया जोड़ते हैं) का मान null_ptrअब है 6। क्या ये एक दिक्कत है? अब आप के लिए एक त्रुटि कोड लौटाते हैं 6और परीक्षण करते हैं 6। जब तक सब कुछ तार्किक रूप से सुसंगत है, आप ठीक हैं, इस बदलाव के बावजूद आपका सैद्धांतिक परीक्षण टूट गया है।
बाल्ड्रिक

17

आप एक एनम घोषणा का परीक्षण नहीं करते हैं । आप परीक्षण कर सकते हैं कि फ़ंक्शन इनपुट / आउटपुट में अपेक्षित एनम मान हैं या नहीं। उदाहरण:

enum Parity {
    Even,
    Odd
}

Parity GetParity(int x) { ... }

आप परीक्षणों की पुष्टि नहीं करते हैं और फिर एनम Parityनामों को परिभाषित करता है Evenऔर Odd। ऐसा परीक्षण व्यर्थ होगा क्योंकि आप सिर्फ वही दोहरा रहे होंगे जो पहले से ही कोड द्वारा कहा गया है। एक ही बात को दो बार कहने से वह अधिक सही नहीं हो जाती।

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

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


मैंने इस उत्तर को संबोधित करने के प्रयास में अपना प्रश्न अपडेट किया है, यह देखने के लिए जांचें कि क्या यह मदद करता है।
IS1_SO 15

@ IS1_SO: ठीक है जो मुझे भ्रमित करता है - क्या आप गतिशील रूप से एनम मान उत्पन्न कर रहे हैं, या क्या हो रहा है?
जैक्सबी

नहीं। मेरा क्या मतलब है कि इस मामले में मूल्यों का प्रतिनिधित्व करने के लिए चयनित भाषा निर्माण एक एनम है। लेकिन जैसा कि हम जानते हैं कि कार्यान्वयन विस्तार है। यदि कोई सरणी का चयन करता है, या मानों का प्रतिनिधित्व करने के लिए कुछ अलग टोकन के साथ एक सेट <> (जावा में) या एक स्ट्रिंग का चयन करता है? अगर ऐसा है तो यह परीक्षण करना समझ में आता है कि निहित मूल्य व्यवसाय के लिए रुचि रखते हैं। वह मेरी बात है। क्या यह स्पष्टीकरण मदद करता है?
IS1_SO

3
@ IS1_SO: क्या आप किसी ऐसे फंक्शन से लौटे एक एनुम उदाहरण का परीक्षण करने की बात कर रहे हैं जिसका एक निश्चित अपेक्षित मूल्य है? क्योंकि हाँ आप परीक्षण कर सकते हैं। आपको बस एनम घोषणा की ही जांच करने की आवश्यकता नहीं है।
जैक्सबी

11

अगर कोई जोखिम है कि एनम को बदलने से आपका कोड टूट जाएगा, तो निश्चित रूप से, सी # में [झंडे] विशेषता के साथ कुछ भी एक अच्छा मामला होगा क्योंकि 2 और 4 (3) के बीच एक मूल्य जोड़ने से बिट 1 और 2 के बजाय एक बिट होगा विचारशील वस्तु।

यह सुरक्षा की एक परत है।

आपको एक एनम कोड ऑफ प्रैक्टिस करने पर विचार करना चाहिए, जिससे सभी डेवलपर परिचित हों। एनम के शाब्दिक निरूपण पर भरोसा मत करो एक आम है, लेकिन यह आपके क्रमबद्ध दिशानिर्देशों के साथ संघर्ष कर सकता है।

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


5
अगर किसी डेटाबेस में संग्रहीत किए गए उदाहरण के लिए, एनम का संख्यात्मक मान कहीं भी उपयोग किया जाता है, तो फिर से रिकॉर्ड करना (अंतिम मान से पहले निकालना या सम्मिलित करना) मौजूदा रिकॉर्ड को अमान्य बना सकता है।
stannius

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

11

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

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


3

आपका कोड किसी एनम के वास्तविक मूल्यों से सही ढंग से स्वतंत्र होना चाहिए। अगर ऐसा है, तो किसी यूनिट टेस्ट की जरूरत नहीं है।

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


1

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

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

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

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


1

Enums केवल परिमित प्रकार हैं, कस्टम (उम्मीद है कि सार्थक) नामों के साथ। एक एनुम का केवल एक ही मान हो सकता है, voidजिसमें केवल nullकुछ होते हैं (कुछ भाषाएं इसे कहते हैं unit, और किसी तत्व के voidसाथ एनम के लिए नाम का उपयोग करें !)। इसके दो मूल्य हो सकते हैं, जैसे कि और । यह तीन तरह हो सकता है, के साथ , और । और इसी तरह।boolfalsetruecolourChannelredgreenblue

यदि दो एनमों में समान मान हैं, तो वे "आइसोमॉर्फिक" हैं; अर्थात यदि हम व्यवस्थित रूप से सभी नामों को बदल देते हैं, तो हम दूसरे के स्थान पर एक का उपयोग कर सकते हैं और हमारा कार्यक्रम कोई अलग व्यवहार नहीं करेगा। विशेष रूप से, हमारे परीक्षण किसी भी अलग तरह से व्यवहार नहीं करेंगे!

उदाहरण के लिए, resultयुक्त win/ lose/ drawऊपर isomorphic को है colourChannel, क्योंकि हम जैसे जगह ले सकता है colourChannelके साथ result, redके साथ win, greenके साथ loseऔर blueसाथ draw, और जब तक हम ऐसा रूप हर जगह (उत्पादकों और उपभोक्ताओं, पारसर्स और serialisers, डेटाबेस प्रविष्टियों, लॉग फाइल, आदि ) तो हमारे कार्यक्रम में कोई बदलाव नहीं होगा। कोई भी " colourChannelपरीक्षण" जो हमने लिखा था वह अभी भी पास होगा, भले ही कोई colourChannelभी अधिक नहीं है!

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

इसका मतलब यह है कि, जहां तक ​​मशीन का संबंध है, एनम "विशिष्ट नाम" हैं और कुछ नहीं । केवल एक चीज जो हम एक एनम के साथ कर सकते हैं वह यह है कि दो मान एक जैसे हैं (जैसे red/ red) या अलग (जैसे red/ blue)। तो यह केवल एक चीज है जो एक 'यूनिट टेस्ट' कर सकता है, जैसे

(  red == red  ) || throw TestFailure;
(green == green) || throw TestFailure;
( blue == blue ) || throw TestFailure;
(  red != green) || throw TestFailure;
(  red != blue ) || throw TestFailure;
...

जैसा कि @ jesm00 कहते हैं, इस तरह के परीक्षण आपके कार्यक्रम के बजाय भाषा कार्यान्वयन की जाँच कर रहे हैं । ये परीक्षण कभी भी एक अच्छा विचार नहीं हैं: भले ही आप भाषा के कार्यान्वयन पर भरोसा नहीं करते हैं, आपको इसे बाहर से परीक्षण करना चाहिए , क्योंकि परीक्षणों को सही ढंग से चलाने के लिए उस पर भरोसा नहीं किया जा सकता है!

तो यह सिद्धांत है; अभ्यास के बारे में क्या? Enums के इस लक्षण वर्णन के साथ मुख्य मुद्दा यह है कि 'वास्तविक दुनिया' कार्यक्रम शायद ही कभी निहित होते हैं: हमारे पास विरासत संस्करण, दूरस्थ / एम्बेडेड तैनाती, ऐतिहासिक डेटा, बैकअप, लाइव डेटाबेस इत्यादि हैं, इसलिए हम वास्तव में 'स्विच आउट' नहीं कर सकते हैं कुछ उपयोगों को याद किए बिना एक नाम की सभी घटनाएं।

फिर भी ऐसी चीजें एनम की 'जिम्मेदारी ’नहीं हैं: एक एनम को बदलने से रिमोट सिस्टम से संपर्क टूट सकता है, लेकिन इसके विपरीत हम एनम को बदलकर इस तरह की समस्या को ठीक कर सकते हैं !

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

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

  • कोड कवरेज हमें बता सकता है कि परीक्षण सूट से आने वाले विभिन्न प्रकार के एनम मान कोड में विभिन्न शाखाओं को ट्रिगर करने के लिए पर्याप्त हैं। यदि नहीं, तो हम उन परीक्षणों को जोड़ सकते हैं जो अनलॉक्ड शाखाओं को ट्रिगर करते हैं, या मौजूदा परीक्षणों में व्यापक रूप से विभिन्न प्रकार के एनम उत्पन्न करते हैं।
  • संपत्ति की जाँच हमें बता सकती है कि क्या कोड में शाखाओं की विविधता रनटाइम संभावनाओं को संभालने के लिए पर्याप्त है। उदाहरण के लिए, यदि कोड केवल संभालता है red, और हम केवल परीक्षण करते हैं red, तो हमारे पास 100% कवरेज है। एक संपत्ति चेकर हमारे दावे के प्रति प्रतिकार पैदा करेगा (जैसे कि हम greenऔर blueपरीक्षण करना भूल गए हैं)।
  • उत्परिवर्तन परीक्षण हमें बता सकता है कि क्या हमारे दावे वास्तव में केवल शाखाओं का पालन करने और उनके मतभेदों की अनदेखी करने के बजाय, एनम की जांच करते हैं।

1

नहीं। यूनिट परीक्षण परीक्षण इकाइयों के लिए हैं।

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, एक इकाई अक्सर एक संपूर्ण इंटरफ़ेस होती है, जैसे कि एक वर्ग, लेकिन एक व्यक्तिगत विधि हो सकती है।

https://en.wikipedia.org/wiki/Unit_testing

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


0

आपसे अपेक्षा की जाती है कि आप अपने कोड के अवलोकनीय व्यवहार का परीक्षण करें, अवलोकनीय अवस्था पर विधि / कार्यकलापों के प्रभाव। जब तक कोड सही काम करता है तब तक आप ठीक हैं, आपको कुछ और परीक्षण करने की आवश्यकता नहीं है।

आपको स्पष्ट रूप से यह दावा करने की आवश्यकता नहीं है कि एक एनुम प्रकार में आपके द्वारा अपेक्षित प्रविष्टियां हैं, जैसे आप स्पष्ट रूप से यह दावा नहीं करते हैं कि एक वर्ग वास्तव में मौजूद है या इसमें आपके द्वारा अपेक्षित तरीके और विशेषताएं हैं।

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

ध्यान दें कि आपको सही काम करने के लिए अपने कोड के लिए सार्थक नामों की आवश्यकता नहीं है, यह सिर्फ आपके कोड को पढ़ने वाले लोगों के लिए एक सुविधा है। आप अपना कोड काम कर सकते हैं जैसे एनम वैल्यूज़ foo, bar... और मेथड्स frobnicate()

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