Use NUnit Assert.Throws method or ExpectedException attribute?

160
votes

I have discovered that these seem to be the two main ways of testing for exceptions:

Assert.Throws<Exception>(()=>MethodThatThrows());

[ExpectedException(typeof(Exception))]

Which of these would be best? Does one offer advantages over the other? Or is it simply a matter of personal preference?

5
c#unit-testingexceptionnunitassert
A 3rd option is the fluent style: Assert.That(() => MethodThatThrows(), Throws.Exception) - Jack Ukleja
NUnit version 3 and later no longer support the ExpectedException attribute, so for version 3+ only the Assert.Throws variant is relevant. - joanlofe
Why is it so? That Nunit3 decided to drop that support? Was googling around and could not find explanation for it... JUnit still supports this way, doesn't it? - ahaaman

5 Answers

266
votes

The main difference is:

ExpectedException() attribute makes test passed if exception occurs in any place in the test method.
The usage of Assert.Throws() allows to specify exact place of the code where exception is expected.

NUnit 3.0 drops official support for ExpectedException altogether.

So, I definitely prefer to use Assert.Throws() method rather than ExpectedException() attribute.

100
votes

The first allows you to test for more than one exception, with multiple calls:

Assert.Throws(()=>MethodThatThrows());
Assert.Throws(()=>Method2ThatThrows());

The second only allows you to test for one exception per test function.

46
votes

I prefer assert.throws since it allows me to verify and assert other conditions after the exception is thrown.

    [Test]
    [Category("Slow")]
    public void IsValidLogFileName_nullFileName_ThrowsExcpetion()
    {
        var a = new MyTestObject();

        // the exception we expect thrown from the IsValidFileName method
        var ex = Assert.Throws<ArgumentNullException>(() => a.IsValidLogFileName(""));

        // now we can test the exception itself
        Assert.That(ex.Message == "Blah");

    }
12
votes

You may also strong type the error you're expecting (like the old attrib version).

Assert.Throws<System.InvalidOperationException>(() => breakingAction())
1
votes

If you are using older version(<=2.0) of NUnit then you need to use ExpectedException.

If you are using 2.5 or later version then you can use Assert.Throw()

https://github.com/nunit/docs/wiki/Breaking-Changes

How to use: https://www.nunit.org/index.php?p=exceptionAsserts&r=2.5