简易扩展Visual Studio UnitTesting支持TestMethodCase

NUnit的TestCaseAttribute可以简化大量的测试参数输入用例的编写，如果基于Visual Studio Unit Test Project开发则默认没有类似的功能，看一段对比代码：

public class MyClass
{
    public Int32 DoWork(String name, Int32 n)
    {
        if (String.IsNullOrWhiteSpace(name))
            throw new ArgumentOutOfRangeException("name");

        if (n < )
            throw new ArgumentOutOfRangeException("n");

        return name.Length / n;
    }
}

[TestClass]
public class MyClassTest
{
    [TestMethod]
    public void DoWork()
    {
        var name = "test";
        var n = ;

        var myClass = new MyClass();
        var result = myClass.DoWork(name, n);

        Assert.IsTrue(result == name.Length / n);
    }

    [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
    public void DoWork_NameIsNull()
    {
        var n = ;

        var myClass = new MyClass();
        myClass.DoWork(null, n);
    }

    [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
    public void DoWork_NameIsEmpty()
    {
        var n = ;

        var myClass = new MyClass();
        myClass.DoWork(String.Empty, n);
    }

    [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
    public void DoWork_NameIsWhiteSpace()
    {
        var n = ;

        var myClass = new MyClass();
        myClass.DoWork(" ", n);
    }

    [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
    public void DoWork_NLessThanZero()
    {
        var name = "test";

        var myClass = new MyClass();
        myClass.DoWork(name, -);
    }
}

可以发现为了测试参数输入验证是否达到预期的效果，额外编写了4个测试用例。如果使用NUnit的TestCase可以简化如下：

[TestFixture]
public class MyClassTest
{
    [TestCase("Test", )]
    [TestCase(null, , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase("", , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase(" ", , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestCase("Test", -, ExpectedException = typeof(ArgumentOutOfRangeException))]
    public void DoWork(String name, Int32 n)
    {
        var myClass = new MyClass();
        var result = myClass.DoWork(name, n);

        Assert.IsTrue(result == name.Length / n);
    }
}

要让Visual Studio Test支持类似的方式可以自己扩展，参考Visual Studio Team Test的Extending the Visual Studio Unit Test Type文章。不过我选择了更为简单的在原有的用例中扩展一个TestMethodCaseAttribute，例如：

[TestClass]
public class MyClassTest
{
    [TestMethod]
    [TestMethodCase("Test", )]
    [TestMethodCase(null, , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestMethodCase("", , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestMethodCase(" ", , ExpectedException = typeof(ArgumentOutOfRangeException))]
    [TestMethodCase("Test", -, ExpectedException = typeof(ArgumentOutOfRangeException))]
    public void DoWork()
    {
        TestMethodCaseHelper.Run(context =>
        {
            var name = context.GetArgument<String>();
            var n = context.GetArgument<Int32>();

            var myClass = new MyClass();
            var result = myClass.DoWork(name, n);

            Assert.IsTrue(result == name.Length / n);
        });
    }
}

只要有一个TestMethodCase未通过，当前的TestMethod既为失败。使用这种方式进行Code Coverage统计并不受影响，可以正确评估

public static class TestMethodCaseHelper
{
    public static void Run(Action<TestMethodCaseContext> body)
    {
        var testMethodCases = FindTestMethodCaseByCallingContext();

        foreach (var testMethodCase in testMethodCases)
            RunTest(testMethodCase, body);
    }

    internal static IEnumerable<TestMethodCaseAttribute> FindTestMethodCaseByCallingContext()
    {
        var stackFrames = StackFrameHelper.GetCurrentCallStack();
        var forTestFrame = stackFrames.FirstOrDefault(p => GetTestMethodCaseAttributes(p).Any());

        return forTestFrame != null ? GetTestMethodCaseAttributes(forTestFrame) : new TestMethodCaseAttribute[];
    }

    private static IEnumerable<TestMethodCaseAttribute> GetTestMethodCaseAttributes(StackFrame stackFrame)
    {
        return GetTestMethodCaseAttributes(stackFrame.GetMethod());
    }

    private static IEnumerable<TestMethodCaseAttribute> GetTestMethodCaseAttributes(MethodBase method)
    {
        return method.GetCustomAttributes(typeof(TestMethodCaseAttribute), true).OfType<TestMethodCaseAttribute>();
    }

    private static void RunTest(TestMethodCaseAttribute testMethodCase, Action<TestMethodCaseContext> body)
    {
        TestSettings.Output.WriteLine("Run TestMethodCase {0} started", testMethodCase.Name);
        var stopwatch = Stopwatch.StartNew();
        RunTestCore(testMethodCase, body);
        stopwatch.Stop();
        TestSettings.Output.WriteLine("Run TestMethodCase {0} finished({1})", testMethodCase.Name, stopwatch.ElapsedMilliseconds);
    }

    private static void RunTestCore(TestMethodCaseAttribute testMethodCase, Action<TestMethodCaseContext> body)
    {
        var testContext = new TestMethodCaseContext(testMethodCase);

        if (testMethodCase.ExpectedException != null)
            RunTestWithExpectedException(testMethodCase.ExpectedException, () => body(testContext));
        else
            body(testContext);
    }

    private static void RunTestWithExpectedException(Type expectedExceptionType, Action body)
    {
        try
        {
            body();
        }
        catch (Exception ex)
        {
            if (ex.GetType() == expectedExceptionType)
                return;

            throw;
        }
    }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public sealed class TestMethodCaseAttribute : Attribute
{
    public TestMethodCaseAttribute(params Object[] arguments)
    {
        this.Arguments = arguments;
    }

    public String Name { get; set; }

    public Type ExpectedException { get; set; }

    public Object[] Arguments { get; private set; }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public sealed class TestMethodCaseAttribute : Attribute
{
    public TestMethodCaseAttribute(params Object[] arguments)
    {
        this.Arguments = arguments;
    }

    public String Name { get; set; }

    public Type ExpectedException { get; set; }

    public Object[] Arguments { get; private set; }
}

public class TestMethodCaseContext
{
    private readonly TestMethodCaseAttribute _testMethodCase;

    internal TestMethodCaseContext(TestMethodCaseAttribute testMethodCase)
    {
        _testMethodCase = testMethodCase;
    }

    public T GetArgument<T>(Int32 index)
    {
        return (T)_testMethodCase.Arguments.ElementAtOrDefault(index);
    }
}

internal static class StackFrameHelper
{
    public static IEnumerable<StackFrame> GetCurrentCallStack()
    {
        var frameIndex = ;

        while (true)
        {
            var stackFrame = new StackFrame(frameIndex, false);

            if (stackFrame.GetILOffset() == StackFrame.OFFSET_UNKNOWN)
                break;

            yield return stackFrame;

            ++frameIndex;
        }
    }
}