.net 给定以下代码，我应该编写哪些测试？

编写单元测试时，我最头疼的一件事是我测试什么，不测试什么

鉴于以下代码，我应该编写哪些测试：

public static class Enforce
{
    public static T ArgumentNotNull<T>(T parameter, string parameterName) where T : class
    {
        if (parameterName.IsNullOrWhiteSpace())
            throw new ArgumentNullException("parameterName");

        if (parameter.IsNull())
            throw new ArgumentNullException(parameterName);

        return parameter;
    }

    public static string ArgumentNotNullOrEmpty(string parameter, string parameterName)
    {
        ArgumentNotNull(parameter, parameterName);

        if (parameter.IsNullOrEmpty())
            throw new ArgumentException(parameterName);

        return parameter;
    }

    public static string ArgumentNotNullOrWhiteSpace(string parameter, string parameterName)
    {
        ArgumentNotNull(parameter, parameterName);

        if (parameter.IsNullOrWhiteSpace())
            throw new ArgumentException(parameterName);

        return parameter;
    }

    public static T NotNull<T>(T instance) where T : class
    {
        instance.IfNullThrow<T, NullReferenceException>(String.Format(EnforceResources.TypeNotNull, typeof(T).FullName));

        return instance;
    }
}

公共静态类强制
{
公共静态T ArgumentNotNull（T参数，字符串参数名称），其中T:class
{
if（parameterName.IsNullOrWhiteSpace（））
抛出新ArgumentNullException（“parameterName”）；
if（parameter.IsNull（））
抛出新ArgumentNullException（parameterName）；
返回参数；
}
公共静态字符串参数NotNullOrEmpty（字符串参数，字符串参数名称）
{
ArgumentNotNull（参数，parameterName）；
if（参数.IsNullOrEmpty（））
抛出新ArgumentException（parameterName）；
返回参数；
}
公共静态字符串参数NotNullorWhitespace（字符串参数，字符串参数名称）
{
ArgumentNotNull（参数，parameterName）；
if（参数.IsNullOrWhiteSpace（））
抛出新ArgumentException（parameterName）；
返回参数；
}
公共静态T NotNull（T实例），其中T:class
{
IfNullThrow（String.Format（EnforceResources.TypeNotNull，typeof（T.FullName））；
返回实例；
}
}

}

我应该为

ArgumentNotNull

编写一个测试，测试抛出的异常，然后测试未抛出的异常吗？我想我的问题是，我应该写我的测试，测试预期，然后完全相反

    [Fact]
    public void ShouldThrowArgumentNullException()
    {
        object arg = null;

        Assert.Throws<ArgumentNullException>(() => { Enforce.ArgumentNotNull(arg, "arg"); });
    }

    [Fact]
    public void ShouldNotThrowArgumentNullException()
    {
        var arg = "Test";

        Assert.DoesNotThrow(() => { Enforce.ArgumentNotNull(arg, "arg"); });
    }

[事实]
public void ShouldThrowArgumentNullException（）
{
对象arg=null；
Assert.Throws（（）=>{Enforce.ArgumentNotNull（arg，“arg”）；}）；
}
[事实]
public void不应通过wargumentnullexception（）
{
var arg=“测试”；
Assert.DoesNotThrow（（）=>{Enforce.ArgumentNotNull（arg，“arg”）；}）；
}

您应该尽最大努力测试所有代码。这意味着所有公共方法和其中的场景都要尽可能多地覆盖其所有内部逻辑

因此，您应该编写3个测试：一个用于第一个异常，一个用于第二个异常，还有一个不抛出任何异常

---

关于这些测试的命名约定，这可能很有趣：

单元测试的概念是确保您的代码完全按照预期工作

因此，如果您希望它抛出异常，那么应该测试它是否存在正确的异常

以下是关于编写单元测试的一些基本概念和技巧：

---

如何命名这些测试？你有没有想过那会是什么样子？