C#：如何为构造函数和构造函数重载编写测试用例？

假设您有一个类的外壳：

public class Number
{
    private int value;

    public Number()
        : this(0) {}

    public Number(int initialValue)
        : this(initialValue, 0, 100) {}

    public Number(int initialValue, int minimumValue, int maximumValue)
    {
        if (minimumValue > maximumValue)
            throw new ArgumentException("Minimum cannot be greater than maximum", "minimumValue");

        MinValue = minimumValue;
        MaxValue = maximumValue;
        Value = initialValue;
    }

    public int MinValue { get; private set; }
    public int MaxValue { get; private set; }

    public int Value
    {
        get { return value; }
        set
        {
            if (value < MinValue)
                value = MinValue;
            if (value > MaxValue)
                value = MaxValue;

            this.value = value;
        }
    }
}

公共类编号
{
私有int值；
公众号码（）
：此（0）{}
公共编号（int initialValue）
：this（initialValue，0100）{}
公共编号（int initialValue、int minimumValue、int maxiumValue）
{
如果（最小值>最大值）
抛出新ArgumentException（“最小值不能大于最大值”、“最小值”）；
最小值=最小值；
最大值=最大值；
值=初始值；
}
public int MinValue{get；private set；}
public int MaxValue{get；private set；}
公共整数值
{
获取{返回值；}
设置
{
如果（值<最小值）
值=最小值；
如果（值>最大值）
值=最大值；
这个值=值；
}
}
}

你会为这个类编写测试吗？如果会，你会如何编写

---

我特别想到了建设者。比如，您是否有一个测试使用默认构造函数创建了一个a

Number

，并检查值是否为0，minvalue是否为0，maxvalue是否为100？还是会超过规格？还是真的没有，因为其他人可能依赖于默认值没有意外更改？您是为每个构造函数编写一个测试，还是只为默认的构造函数编写一个测试，因为您知道它贯穿所有其他构造函数

我已经完全从传统的TDD方法转向更现代、更符合逻辑的BDD（行为驱动设计）。对于Number类，我将编写以下BDD规范（注意，下面的语法是用完成的，它依赖于）：

此外，我注意到您的完整构造函数也可能有一个例外情况，即最小值大于最大值。在这种特殊情况下，您还需要验证行为是否正确：

public void Full_constructor_throws_proper_exception_when_minvalue_greater_than_maxvalue()
{
    // State
    Number number = null;
    Exception expectedEx = null;

    // Context
    "Given a null context".Context(() => {});

    // Concern
    "when creating a new Number with inverted min and max values".Do(
        () => 
        { 
            try { number = new Number(10, 50, 1); }
            catch (Exception ex) { expectedEx = ex }
        }
     );

    // Observations
    "an exception should be thrown".Assert(() => Assert.NotNull(expectedEx));
    "the exception should be an ArgumentException".Assert(() => Assert.IsType<ArgumentException>(expectedEx));
}

public void Full\u构造函数在\u minvalue\u大于\u maxvalue（）时抛出\u property\u exception\u
{
//陈述
数字=空；
异常expectedEx=null；
//上下文
“给定一个空上下文”。上下文（（）=>{}）；
//关心
“创建具有反转最小值和最大值的新数字时”。是否执行(
() => 
{ 
试试{number=新的数字（10,50,1）；}
catch（异常ex）{expectedEx=ex}
}
);
//观察
“应该引发异常”。Assert（（）=>Assert.NotNull（expectedEx））；
“异常应该是ArgumentException”。断言（（）=>Assert.IsType（expectedEx））；
}

---

上述规范应为您提供100%的测试覆盖率。当使用xunit.net执行时，它们还会生成一个非常好的、可读的、逻辑性强的报告，并输出默认报告。

我已经完全从传统的TDD方法切换到了更现代、逻辑性更强的BDD（行为驱动设计）。对于Number类，我将编写以下BDD规范（注意，下面的语法是用完成的，它依赖于）：

此外，我注意到您的完整构造函数也可能有一个例外情况，即最小值大于最大值。在这种特殊情况下，您还需要验证行为是否正确：

public void Full_constructor_throws_proper_exception_when_minvalue_greater_than_maxvalue()
{
    // State
    Number number = null;
    Exception expectedEx = null;

    // Context
    "Given a null context".Context(() => {});

    // Concern
    "when creating a new Number with inverted min and max values".Do(
        () => 
        { 
            try { number = new Number(10, 50, 1); }
            catch (Exception ex) { expectedEx = ex }
        }
     );

    // Observations
    "an exception should be thrown".Assert(() => Assert.NotNull(expectedEx));
    "the exception should be an ArgumentException".Assert(() => Assert.IsType<ArgumentException>(expectedEx));
}

public void Full\u构造函数在\u minvalue\u大于\u maxvalue（）时抛出\u property\u exception\u
{
//陈述
数字=空；
异常expectedEx=null；
//上下文
“给定一个空上下文”。上下文（（）=>{}）；
//关心
“创建具有反转最小值和最大值的新数字时”。是否执行(
() => 
{ 
试试{number=新的数字（10,50,1）；}
catch（异常ex）{expectedEx=ex}
}
);
//观察
“应该引发异常”。Assert（（）=>Assert.NotNull（expectedEx））；
“异常应该是ArgumentException”。断言（（）=>Assert.IsType（expectedEx））；
}

上述规范应为您提供100%的测试覆盖率。当使用xunit.net执行时，它们还会生成一个非常漂亮、可读的逻辑报告，并输出默认报告。

使用nunit

创建一个测试，为每个构造函数创建一个对象。使用Assert.AreEqual确保所有对象都相等（对于这样的类，应该重写Equals）。更确切地说，负断言assert.aream断言

然后测试每个属性的正确值

如果您的类更复杂，并且希望更加小心，那么可以将所有值设置为唯一的随机数，并断言属性是从随机数据集正确初始化的。

使用nunit

创建一个测试，为每个构造函数创建一个对象。使用Assert.AreEqual确保所有对象都相等（对于这样的类，应该重写Equals）。更确切地说，负断言assert.aream断言

然后测试每个属性的正确值

---

如果你的课比较复杂，你想更加小心，然后，您可以将所有值设置为唯一的随机数，并断言属性是从随机数据集中正确初始化的。

我想您有几个构造函数是有原因的-尝试测试场景，而不是根据某些规则初始化类。
例如，如果使用默认构造函数为动态计算测试创建一个类，而不是默认构造函数设置了某个值

---

我的观点是，您不应该有您不使用的重载（除非您正在开发API），那么为什么不测试用例而不是构造函数呢。

我想您有几个构造函数是有原因的-尝试测试场景，而不是根据某个规则初始化类。
例如，如果使用默认构造函数创建cla

[TestMethod]
public void Constructor_FullTest()
{

    IDrawingContext context = new Mock<IDrawingContext>().Object; 

    ConstructorTests<Frame>
        .For(typeof(int), typeof(int), typeof(IDrawingContext))
        .Fail(new object[] { -3, 5, context }, typeof(ArgumentException), "Negative  length")
        .Fail(new object[] { 0, 5, context }, typeof(ArgumentException), "Zero length")
        .Fail(new object[] { 5, -3, context }, typeof(ArgumentException), "Negative width")
        .Fail(new object[] { 5, 0, context }, typeof(ArgumentException), "Zero width")
        .Fail(new object[] { 5, 5, null }, typeof(ArgumentNullException), "Null drawing context")
        .Succeed(new object[] { 1, 1, context }, "Small positive length and width")
        .Succeed(new object[] { 3, 4, context }, "Larger positive length and width")
        .Assert();

}