简易扩展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;

        }

    }

}

巴特西

简易扩展Visual Studio UnitTesting支持TestMethodCase

最新文章

热门文章