How do you test for the specific reason an exception was thrown?

Question

What is the correct way to determine exactly what caused an exception, to correct it?

Consider the code below. I attempt to parse a string of XML, but occasionally, the incoming XML will not be top-level, meaning it needs to be surrounded by a root element.

Which this happens, the parser throws an XmlException, but it could throw that for a lot of reasons. I want to catch this one specific reason.

I do this, which I concede is probably not great:

var doc = new XmlDocument();
try
{
    doc.LoadXml(xml);
}
catch(XmlException e)
{
    if(e.Message.Contains("multiple root elements"))
    {
        doc.LoadXml($"<root>{xml}</root>");
    }
    else
    {
        throw e;
    }
}

This feels like a hack. What is the correct way to do this?

Answer 1

There is a new feature of C# that allows you to filter exceptions in the catch clause with when keyword:

try
{

} 
catch (XmlException ex) when ( ex.Message.Contains(...) )
{
   //handle
}

You can use multiple fields to recognize the exception type, like the InnerException, StackTrace, and Data. As @David Hruška suggests, the HResult property is also a good place to check to recognize the type of the exception

The Message is not the best property to use for the check, as it is usually localized for the built-in types and as a result might look different with other culture setting.

Answer 2

you can try to make a switch for XmlException.HResult as described here:

https://msdn.microsoft.com/en-us/library/system.xml.xmlexception(v=vs.110).aspx

The only thing I am not sure, if it points the the specific exception type (like XmlException) or specific exception "message".

If this does not help, I think you have no other option than checking for message.

EDIT: Also, as was pointed above, you should throw; instead of throw e; as the second clears the StackTrace. ReSharper also warns about this one.

Answer 3

There are multiple ways to achieve what you're trying to do. Different test frameworks bring their own tools to help with this too. For example, if you're using MSVS Test Framework, the simplest option is to only check for the exception type. In this case you just mark the test method with "ExceptedExceptionAttribute" and specify the expected exception type to be thrown from the method, as follows:

[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void Action_ThrowsException()
{
    // test logic here
}

There is another constructor available, which allows to specify the exact exception message as the second parameter, which is rarely used. You can find the documentation for ExpectedExceptionAttribute in MSDN.

Another option, where you have more control, would be what was already suggested in the other answers, which can be encapsulated in a helper method as follow:

private static T Throws<T>(Action action) where T : Exception
{
    try
    {
        action();
        Assert.Fail();
    }
    catch (T ex)
    {
        // This exception was expected.
        return ex;
    }
}

Using this helper method, you now can have your test method as follows:

[TestMethod]
public void Action_ThrowsException()
{
    // test logic here
    ArgumentException aex = Throws<ArgumentException>(()=>{
        // Test logic here
    });

    Assert.AreEqual("Expected error message", aex.Message);
}

As you can see, this option provides you with higher flexibility as you can now validate other aspects of the exception explicitly.

FYI: The second solution is given as part of the xUnit framework.