单元测试异常属性

Question

我有例外

class SyntaxError : Exception {
    public SyntaxError(int l) {
        line = l;
    }
    public int line;
}

我正在使用单元测试来测试 class 解析器，它在特定输入上应该抛出上面的异常。我正在使用这样的代码：

    [TestMethod]
    [ExpectedException(typeof(Parser.SyntaxError))]
    public void eolSyntaxError()
    {
        parser.reader = new StringReader("; alfa\n; beta\n\n\n\na");
        parser.eol();
    }

是否有任何智能简单的方法来检查是否 SyntaxError.line == 1？

我想到的最好的是：

    [TestMethod]
    public void eolSyntaxError()
    {
        try {
            parser.reader = new StringReader("; alfa\n; beta\n\n\n\na");
            parser.eol();
            Assert.Fail();
        } catch (SyntaxError e) {
            Assert.AreEqual(1, e.line);
        }
    }

不太喜欢，有没有更好的办法？

Answer 1

根据我的评论，如果您遇到语法错误的行是相关的，那么将其包含在您的自定义异常中 class，就像这样。

public class SyntaxError : Exception
{
     public SyntaxError(int atLine)
     {
         AtLine = atLine;
     }

     public int AtLine { get; private set; }
}

然后就很容易测试了

编辑 - 阅读问题 (!) 后，这里有一个简单的附加断言方法，它将整理您的异常断言。

public static class xAssert
{
    public static TException Throws<TException>(Action a) where TException : Exception
    {
        try
        {
            a();
        }
        catch (Exception ex)
        {
            var throws = ex as TException;
            if (throws != null)
                return throws;
        }
        Assert.Fail();
        return default(TException);
    }
}

用法如下...

public class Subject
{
    public void ThrowMyException(int someState)
    {
        throw new MyException(someState);
    }

    public void ThrowSomeOtherException()
    {
        throw new InvalidOperationException();
    }
}

public class MyException : Exception
{
    public int SomeState { get; private set; }

    public MyException(int someState)
    {
        SomeState = someState;
    }
}

[TestClass]
public class UnitTest1
{
    [TestMethod]
    public void TestMethod1()
    {
        var subject = new Subject();
        var exceptionThrown = xAssert.Throws<MyException>(() => { subject.ThrowMyException(123); });

        Assert.AreEqual(123, exceptionThrown.SomeState);
    }
}

Answer 2

我不知道对此有开箱即用的解决方案，但我见过这样工作的期望概念：

[TestMethod]
public void EolSyntaxError()
{
    Expectations.Expect<(SyntaxError>(
        () =>
        {
            parser.reader = new StringReader("; alfa\n; beta\n\n\n\na");
            parser.eol();
        },
        e =>
        {
            Assert.AreEqual(1, e.line);
        });
}

期望需要实现。我估计会有一些图书馆已经这样做了。无论如何，Expectations 中的 Expect 方法可能如下所示：

public static void Expect<TExpectedException>(
    System.Action action,
    System.Action<TExpectedException> assertion) where TExpectedException : Exception
{
    if (action == null) { throw new ArgumentNullException("action"); }
    try
    {
        action.Invoke();
        Assert.Fail(string.Format("{0} expected to be thrown", typeof(TExpectedException).Name));
    }
    catch (TExpectedException e)
    {
        assertion.Invoke(e);
    }
}

Answer 3

考虑使用 FluentAssertions。您的测试将如下所示：

[TestMethod]
public void eolSyntaxError()
{
    parser.reader = new StringReader("; alfa\n; beta\n\n\n\na");

    Action parseEol = () => parser.eol();

    parseEol
        .ShouldThrow<SyntaxError>()
        .And.line.Should().Be(1);
}

否则，您的方法已经很不错了。

Answer 4

你可以写一个类似于 NUnit

的方法

public T Throws<T>(Action code) where T : Exception
{
    Exception coughtException = null;
    try
    {
        code();
    }
    catch (Exception ex)
    {
        coughtException = ex;
    }

    Assert.IsNotNull(coughtException, "Test code didn't throw exception");
    Assert.AreEqual(coughtException.GetType(), typeof(T), "Test code didn't throw same type exception");

    return (T)coughtException;
}

然后你可以在你的测试方法中使用它

Parser.SyntaxError exception = Throws<Parser.SyntaxError>(() => parser.eol());
Assert.AreEqual(1, exception.line);

单元测试异常属性

Unit testing exception property

c#

unit-testing

单元测试异常 属性

Unit testing exception property

c#

unit-testing

单元测试异常属性