आप इंटरफ़ेस का परीक्षण कैसे करते हैं?

Question

उदाहरण के लिए, वहाँ एक इंटरफेस IMyInterface है, और तीन वर्गों इस इंटरफ़ेस का समर्थन:

class A : IMyInterface 
{ 
} 

class B : IMyInterface 
{ 
} 

class C : IMyInterface 
{ 
} 

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

(previously asked on the MSDN forums)

Answer 1

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

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

Answer 2

तरीकों कि प्रकार IMyInterface की एक पैरामीटर लेने के लिए और वास्तविक परीक्षण तरीकों सिर्फ उन तरीकों विभिन्न ठोस वर्ग में गुजर कॉल बनाया जा सका।

Answer 3

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

Answer 4

आप अपने इंटरफेस के विभिन्न कार्यान्वयन NUnit एक उदाहरण के रूप में प्रयोग के खिलाफ एक ही परीक्षण चलाने के लिए चाहते हैं:

public interface IMyInterface {} 
class A : IMyInterface { } 
class B : IMyInterface { } 
class C : IMyInterface { } 

public abstract class BaseTest 
{ 
    protected abstract IMyInterface CreateInstance(); 

    [Test] 
    public void Test1() 
    { 
     IMyInterface instance = CreateInstance(); 
     //Do some testing on the instance... 
    } 

    //And some more tests. 
} 

[TestFixture] 
public class ClassATests : BaseTest 
{ 
    protected override IMyInterface CreateInstance() 
    { 
     return new A(); 
    } 

    [Test] 
    public void TestCaseJustForA() 
    { 
     IMyInterface instance = CreateInstance(); 
     //Do some testing on the instance... 
    } 

} 

[TestFixture] 
public class ClassBTests : BaseTest 
{ 
    protected override IMyInterface CreateInstance() 
    { 
     return new B(); 
    } 
} 

[TestFixture] 
public class ClassCTests : BaseTest 
{ 
    protected override IMyInterface CreateInstance() 
    { 
     return new C(); 
    } 
} 

Answer 5

आप NUnit का उपयोग कर रहे हैं, तो आप इस्तेमाल कर सकते हैं Grensesnitt:

public interface ICanAdd { 
    int Add(int i, int j); //dont ask me why you want different adders 
} 

public class winefoo : ICanAdd { 
    public int Add(int i, int j) 
    { 
     return i + j; 
    } 
} 

interface winebar : ICanAdd { 
    void FooBar() ; 
} 

public class Adder1 : winebar { 
    public int Add(int i, int j) { 
     return i + j; 
    } 
    public void FooBar() {} 
} 

public class Adder2 : ICanAdd { 
    public int Add(int i, int j) { 
     return (i + 12) + (j - 12); //yeeeeeaaaah 
    } 
} 

[InterfaceSpecification] 
public class WithOtherPlugins : AppliesToAll<ICanAdd> 
{ 
    [TestCase(1, 2, 3)] 
    [TestCase(-1, 2, 1)] 
    [TestCase(0, 0, 0)] 
    public void CanAddOrSomething(int x, int y, int r) 
    { 
     Assert.AreEqual(subject.Add(x, y), r); 
    } 

    [TestCase(1, 2, Result = 3)] 
    [TestCase(-1, 2, Result = 1)] 
    [TestCase(0, 0, Result = 0)] 
    public int CannAddOrSomethingWithReturn(int x, int y) { 
     return subject.Add(x, y); 
    } 
}