2010-05-12 14 views
10

जेनेरिक कक्षाओं/विधियों के यूनिट परीक्षण को कवर करने का अनुशंसित तरीका क्या है?जेनेरिक कक्षाओं/विधियों के लिए यूनिट परीक्षण दृष्टिकोण

उदाहरण के लिए (नीचे मेरे उदाहरण कोड का जिक्र है)। क्या यह कुछ अलग-अलग प्रकार के टीकेई, टीएनओडी कक्षाओं के तरीकों का परीक्षण करने के लिए 2 या 3 बार परीक्षणों का मामला होगा? या सिर्फ एक वर्ग पर्याप्त है?

public class TopologyBase<TKey, TNode, TRelationship> 
    where TNode : NodeBase<TKey>, new() 
    where TRelationship : RelationshipBase<TKey>, new() 

{ 
    // Properties 
    public Dictionary<TKey, NodeBase<TKey>> Nodes { get; private set; } 
    public List<RelationshipBase<TKey>> Relationships { get; private set; } 

    // Constructors 
    protected TopologyBase() 
    { 
     Nodes = new Dictionary<TKey, NodeBase<TKey>>(); 
     Relationships = new List<RelationshipBase<TKey>>(); 
    } 

    // Methods 
    public TNode CreateNode(TKey key) 
    { 
     var node = new TNode {Key = key}; 
     Nodes.Add(node.Key, node); 
     return node; 
    } 

    public void CreateRelationship(NodeBase<TKey> parent, NodeBase<TKey> child) { 
    . 
    . 
    . 
+1

मैं सिर्फ इसी प्रकार के प्रश्न पूछने जा रहा था। – Casey

उत्तर

3

मैं आमतौर पर परीक्षण उद्देश्य के लिए एक DummyClass बनाने एक सामान्य तर्क के रूप में पारित करने के लिए (आपके मामले में आप 3 वर्ग बनाना चाहिए) और मैं कक्षा (TopologyBase) एक बार परीक्षण करें।

विभिन्न सामान्य प्रकारों के साथ परीक्षण करना समझ में नहीं आता है, क्योंकि जेनेरिक प्रकार को टोपोलॉजीबेस क्लास को तोड़ना नहीं चाहिए।

+0

तो इंटीजर कहने का एक सामान्य वर्ग बनाने के बजाय, आप जेनेरिक क्लास का परीक्षण करने के लिए विशेष रूप से उपयोग की जाने वाली एक नई कक्षा तैयार करेंगे। क्या आप नई कक्षा में कोई कार्यक्षमता जोड़ देंगे? – Casey

+0

बिल्कुल। नई कक्षा को डमी होना चाहिए जो कुछ भी नहीं करता है। – ema

1

आप अपनी कक्षा और सामान्य प्रकार के बीच अपेक्षित बातचीत को सत्यापित करने के लिए एक मॉकिंग फ्रेमवर्क का उपयोग कर सकते हैं। मैं इसके लिए Rhino Mocks का उपयोग करता हूं।

1

इकाई को खुले उत्पादन प्रकार का परीक्षण करने के लिए, खुले प्रकार से प्राप्त एक परीक्षण कोड प्रकार बनाएं - फिर उस प्रकार का परीक्षण करें।

public class TestingTopologyBase : TopologyBase<KeyType, NodeType, RelationshipType> ... 

TestingTopologyBase वर्ग में, किसी भी सार तरीकों या कुछ और कि अनिवार्य है के आधार कार्यान्वयन प्रदान करते हैं।

ये परीक्षण [उत्पादन प्रकार] कार्यान्वयन अक्सर आपके यूनिट टेस्ट कोड के लिए उत्कृष्ट स्थान होते हैं ताकि यह समझ सके कि परीक्षण के तहत जेनेरिक प्रकार वास्तव में क्या कर रहा है। उदाहरण के लिए, आप उस जानकारी को स्टोर कर सकते हैं जिसे परीक्षण के दौरान क्या हुआ, उसका निरीक्षण करने के लिए बाद में आपके यूनिट टेस्ट कोड द्वारा उपयोग किया जा सकता है।

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

उदाहरण:

[TestClass] 
public class TopologyBaseFixture { 

    [TestMethod] 
    public void SomeTestMethod() { 
     var foo = new TestingTopologyBase(...); 
     ...test foo here 
2

यह वास्तव में अपने कोड पर निर्भर करता है हो सकता है लेकिन वहाँ कम से कम दो चीजों के बारे में सोचने के लिए कर रहे हैं:

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

बहुत आपकी सामान्य बाधाओं पर निर्भर करता है। यदि एक या अधिक प्रकार के पैरामीटर को इंटरफ़ेस या बेस क्लास बाधा की आवश्यकता होती है, तो अब इंटरफ़ेस अनुबंध पर निर्भरता है। चूंकि आपकी कक्षा का तर्क आंशिक रूप से इंटरफ़ेस को लागू करने वाले वर्ग के व्यवहार पर निर्भर हो सकता है, इसलिए आपको अपने सभी लॉजिकल मार्गों का उपयोग करने के लिए इंटरफ़ेस को विभिन्न तरीकों से नकल करने की आवश्यकता हो सकती है।उदाहरण के लिए, यदि आपके पास T: IEquatable<T> है, तो आपको एक int की तरह सार्थक समानता व्यवहार के साथ एक प्रकार का उपयोग करने की आवश्यकता होगी।

संबंधित मुद्दे