C# 单元测试-如何测试这个类_C#_Unit Testing

C# 单元测试-如何测试这个类

c# unit-testing

C# 单元测试-如何测试这个类,c#,unit-testing,C#,Unit Testing,我创建了类缓存（wrappsSystem.Runtime.Caching.MemoryCache），它具有以下公共方法： bool Add(string key, object value) bool Contains(string key) 如何测试Contains（）方法，而不首先使用Add（）方法将项添加到缓存？？？当然，如果我在单元测试中为Contains（）方法使用Add（）如何在不首先使用Add（）方法向缓存添加项的情况下测试Contains（）方法断言它返回false 如果我

我创建了

类缓存

（wrapps

System.Runtime.Caching.MemoryCache

），它具有以下公共方法：

bool Add(string key, object value)
bool Contains(string key)

如何测试

Contains（）

方法，而不首先使用

Add（）

方法将项添加到缓存？？？当然，如果我在单元测试中为

Contains（）

方法使用

Add（）
如何在不首先使用Add（）方法向缓存添加项的情况下测试Contains（）方法
断言它返回false
如果我在Contains（）方法的单元测试中使用Add（）方法，这肯定是错误的吗
当然不是。您正在测试一个单元，它的Contains（）
在您调用Add（）
后，其行为有所不同。如果不在Add（）
之后调用Contains（）
的测试，则是错误的
如何在不首先使用Add（）方法向缓存添加项的情况下测试Contains（）方法
断言它返回false
如果我在Contains（）方法的单元测试中使用Add（）方法，这肯定是错误的吗
当然不是。您正在测试一个单元，它的Contains（）
在您调用Add（）
后，其行为有所不同。如果不在Add（）
之后调用Contains（）
的测试，则是错误的
如何在不首先使用Add（）方法向缓存添加项的情况下测试Contains（）方法
断言它返回false
如果我在Contains（）方法的单元测试中使用Add（）方法，这肯定是错误的吗
当然不是。您正在测试一个单元，它的Contains（）
在您调用Add（）
后，其行为有所不同。如果不在Add（）
之后调用Contains（）
的测试，则是错误的
如何在不首先使用Add（）方法向缓存添加项的情况下测试Contains（）方法
断言它返回false
如果我在Contains（）方法的单元测试中使用Add（）方法，这肯定是错误的吗
当然不是。您正在测试一个单元，它的Contains（）
在您调用Add（）
后，其行为有所不同。在Add（）
之后没有调用Contains（）
的测试是错误的。
我想我理解你的困境。您正在询问是否使用一种新方法来测试另一种新方法。有点像用未知测试未知
对我来说，我会把它看作是假设的测试隔离案例。让我解释一下
如果两种方法都存在，并且您负责测试它们，则以下内容适用
在第一个实例中，您希望测试Add（，）方法。在这种情况下，我会“假设”所有其他方法都能正常工作。因此，在这种情况下，我将运行Add（key，value）并检查它是否断言为true，然后通过调用Contains（key）进行验证并确保它断言为true。即使Contains（）未经测试
然后在第二个实例中，假设Add（，）工作正常，并测试Contains（）方法。我总是基于这样的假设进行测试，即我已经打开了指示灯，并且测试了一些特定的东西、特定的方法、特定的类，并且假设运行测试所需的所有支持都是有效的
事实上，情况并非总是如此，一些支持方法并没有像预期的那样起作用。但是，测试会让你知道。这就是它的目的。以帮助揭示这些问题
您可能已经想到了这个测试，但是，这里有一个快速的示例，您可以将这两个方法的测试组合到一个测试中。当然，您可以将其分为两个测试（一个以Add（）为中心，另一个以Contains（）为中心），但它们看起来非常相似。我希望有帮助
public class SomeClass : MemoryCache
{
    public SomeClass() : base("Test")
    {
    }

    public bool Add(string key, object value)
    {
        return Add(key, value, DateTime.Now.AddDays(1));
    }
}

[TestFixture]
public class TestSomeClass
{
    [Test]
    public void TestSomeClassMethod1()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }
}

但在纯TDD方法中，您可以这样做：
创建Add（，）方法，然后编写以下测试：
   [Test]        
    public void TestAdd()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsTrue(instance.Add(key, new object()));
    }

    [Test]
    public void TestContains()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        // A purest will say that you don't need the following Assert
        // for the Add as it is not what you are testing. 
        // But I don't see any harm
        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }

然后创建Contains（）方法，然后编写以下测试：
   [Test]        
    public void TestAdd()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsTrue(instance.Add(key, new object()));
    }

    [Test]
    public void TestContains()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        // A purest will say that you don't need the following Assert
        // for the Add as it is not what you are testing. 
        // But I don't see any harm
        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }

我想我理解你的困境。您正在询问是否使用一种新方法来测试另一种新方法。有点像用未知测试未知
对我来说，我会把它看作是假设的测试隔离案例。让我解释一下
如果两种方法都存在，并且您负责测试它们，则以下内容适用
在第一个实例中，您希望测试Add（，）方法。在这种情况下，我会“假设”所有其他方法都能正常工作。因此，在这种情况下，我将运行Add（key，value）并检查它是否断言为true，然后通过调用Contains（key）进行验证并确保它断言为true。即使Contains（）未经测试
然后在第二个实例中，假设Add（，）工作正常，并测试Contains（）方法。我总是基于这样的假设进行测试，即我已经打开了指示灯，并且测试了一些特定的东西、特定的方法、特定的类，并且假设运行测试所需的所有支持都是有效的
事实上，情况并非总是如此，一些支持方法并没有像预期的那样起作用。但是，测试会让你知道。这就是它的目的。以帮助揭示这些问题
您可能已经想到了这个测试，但是，这里有一个快速的示例，您可以将这两个方法的测试组合到一个测试中。当然，您可以将其分为两个测试（一个以Add（）为中心，另一个以Contains（）为中心），但它们看起来非常相似。我希望有帮助
public class SomeClass : MemoryCache
{
    public SomeClass() : base("Test")
    {
    }

    public bool Add(string key, object value)
    {
        return Add(key, value, DateTime.Now.AddDays(1));
    }
}

[TestFixture]
public class TestSomeClass
{
    [Test]
    public void TestSomeClassMethod1()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }
}

但在纯TDD方法中，您可以这样做：
创建Add（，）方法，然后编写以下测试：
   [Test]        
    public void TestAdd()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsTrue(instance.Add(key, new object()));
    }

    [Test]
    public void TestContains()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        // A purest will say that you don't need the following Assert
        // for the Add as it is not what you are testing. 
        // But I don't see any harm
        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }

然后创建Contains（）方法，然后编写以下测试：
   [Test]        
    public void TestAdd()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsTrue(instance.Add(key, new object()));
    }

    [Test]
    public void TestContains()
    {
        var instance = new SomeClass();

        const string key = "someKey";
        Assert.IsFalse(instance.Contains(key));

        // A purest will say that you don't need the following Assert
        // for the Add as it is not what you are testing. 
        // But I don't see any harm
        Assert.IsTrue(instance.Add(key, new object()));
        Assert.IsTrue(instance.Contains(key));

        instance.Remove(key);
        Assert.IsFalse(instance.Contains(key));
    }

我想我理解你的困境。你在问我