Testing for Exceptions

std.exception module

It is common to test some code for exception types that it should or should not throw under certain conditions. The std.exception module contains two functions that help with testing for exceptions:

• assertThrown: ensures that a specific exception type is thrown from an expression

• assertNotThrown: ensures that a specific exception type is not thrown from an expression

For example, a function that requires that both of its slice parameters have equal lengths and works with empty slices can be tested as in the following tests:

import std.exception;
int[] average(int[] a, int[] b) {
    // ...
}
unittest {
    /* Must throw for uneven slices */ 
    assertThrown(average([1], [1, 2]));
    /* Must not throw for empty slices */
    assertNotThrown(average([], [])); 
}

Normally, assertThrown ensures that some type of exception is thrown without regard to the actual type of that exception. When needed, it can test against a specific exception type as well. Likewise, assertNotThrown ensures that no exception is thrown whatsoever, but it can be instructed to test that a specific exception type is not thrown. The specific exception types are specified as template parameters to these functions:

/* Must throw UnequalLengths for uneven slices */
assertThrown!UnequalLengths(average([1], [1, 2]));
/* Must not throw RangeError for empty slices (it may
 * throw other types of exceptions) */
assertNotThrown!RangeError(average([], []));

The main purpose of these functions is to make code more succinct and more readable. For example, the following assertThrown line is the equivalent of the lengthy code below it:

assertThrown(average([1], [1, 2]));
// ...
    /* The equivalent of the line above */
    {
        auto isThrown = false;

        try {
            average([1], [1, 2]);
        } catch (Exception exc) {
            isThrown = true; 
        }

        assert(isThrown);
    }

---

In the next lesson, we will explore test-driven development for unit testing.