Enums केवल परिमित प्रकार हैं, कस्टम (उम्मीद है कि सार्थक) नामों के साथ। एक एनुम का केवल एक ही मान हो सकता है, void
जिसमें केवल null
कुछ होते हैं (कुछ भाषाएं इसे कहते हैं unit
, और किसी तत्व के void
साथ एनम के लिए नाम का उपयोग करें !)। इसके दो मूल्य हो सकते हैं, जैसे कि और । यह तीन तरह हो सकता है, के साथ , और । और इसी तरह।bool
false
true
colourChannel
red
green
blue
यदि दो एनमों में समान मान हैं, तो वे "आइसोमॉर्फिक" हैं; अर्थात यदि हम व्यवस्थित रूप से सभी नामों को बदल देते हैं, तो हम दूसरे के स्थान पर एक का उपयोग कर सकते हैं और हमारा कार्यक्रम कोई अलग व्यवहार नहीं करेगा। विशेष रूप से, हमारे परीक्षण किसी भी अलग तरह से व्यवहार नहीं करेंगे!
उदाहरण के लिए, 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
परीक्षण करना भूल गए हैं)।
- उत्परिवर्तन परीक्षण हमें बता सकता है कि क्या हमारे दावे वास्तव में केवल शाखाओं का पालन करने और उनके मतभेदों की अनदेखी करने के बजाय, एनम की जांच करते हैं।