Ünite bir arayüzü nasıl test ediyor? Örneğin

Question

, bir arayüz IMyInterface var ve üç sınıfları bu arayüzünü destekleyen:

class A : IMyInterface 
{ 
} 

class B : IMyInterface 
{ 
} 

class C : IMyInterface 
{ 
} 

En basit şekilde, ben üç test sınıf yazabilirsiniz: ATest, BTest, CTest ve bunları ayrı ayrı test edin. Ancak, aynı arayüzü destekledikleri için, çoğu test kodu aynı olurdu, sürdürmesi zor. Farklı sınıf tarafından desteklenen bir arabirimi sınamak için basit ve kolay bir yolu nasıl kullanabilirim?

(previously asked on the MSDN forums)

Answer 1

Uygulamadan bağımsız olarak ortak testlerle bir arayüzü test etmek için, soyut bir test durumu kullanabilir ve daha sonra arabirimin her bir uygulaması için test vakasının somut örneklerini oluşturabilirsiniz. .

Soyut (temel) test durumu, uygulama-nötr testleri gerçekleştirir (yani, arabirim sözleşmesini doğrulayın), somut testler, nesneyi sınamanın gerçekleştirilmesiyle ilgilenir ve uygulamaya özel testleri gerçekleştirir.

Answer 2

tip IMyInterface bir parametre almak ve gerçek test yöntemleri sadece farklı beton sınıflarında geçen bu yöntemleri aramasını yöntemleri oluşturmak olabilir.

Answer 3

Arabirimi doğrudan test etmiyorsunuz, ancak belirli bir uygulamanın uzatması gereken sözleşmeyi test eden soyut bir sınıf yazabilirsiniz. Bir somut sınıfa ait bir test daha sonra soyut sınıfını genişletir

Answer 4

Eğer bir örnek olarak NUnit kullanarak arayüzünün farklı uygulayıcılar karşı aynı testler isterseniz: Grensesnitt

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

Eğer NUnit kullanıyorsanız, o zaman kullanabilirsiniz:

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); 
    } 
}