Syntactic Sugar for Thrown Exception Checking with Generics

alecl — Sat, 25 Oct 2008 15:52:00 GMT

Using attributes like [ExpectedException] can obscure intent because they apply to the whole method instead of a specific call you're checking. To make intent totally clear and prevent unexpected bugs, you should wrap just the statement you're expecting an exception from in a try/catch:

int y = 0;

try
{
    int x = 1 / y;
    Assert.Fail("Exception not thrown DivideByZeroException");
}
catch (DivideByZeroException)
{
}

In addition, at times the same exception is thrown, but with different descriptive messages and in the interest of checking correctness we need to check the message as well. To help achieve DRY, clarity, and expressiveness, I've created some helper methods for my unit tests to deal with testing proper exception throwing. Note that to be totally by the book, you likely should be creating special custom exceptions for each type rather than checking the message strings, but this can be superfluous at times so the option is here.

public class SpecHelpers
{
    public static void ExpectException<T>(Action methodCall) where T : Exception
    {
        bool caught = false;

        try
        {
            methodCall();
        }
        catch (T)
        {
            caught = true;
        }

        if (!caught)
            Assert.Fail(String.Format("Expected exception {0} not thrown"));
    }

    public static void ExpectExceptionMessageStartsWith<T>(Action methodCall, string startsWith) where T : Exception
    {
        bool caught = false;

        try
        {
            methodCall();
        }
        catch (T ex)
        {
            if (!ex.Message.StartsWith(startsWith, true, null))
                Assert.Fail(String.Format("Expected exception {0} thrown, but message didn't start with \"{1}\".  Message: \"{2}\"", 
                            ex.GetType().FullName, startsWith, ex.Message));

            caught = true;
        }

        if (!caught)
            Assert.Fail(String.Format("Expected exception {0} not thrown"), typeof(T).FullName);
    }

    public static void ExpectExceptionMessageContains<T>(Action methodCall, string contains) where T : Exception
    {
        bool caught = false;

        try
        {
            methodCall();
        }
        catch (T ex)
        {
            if (ex.Message.IndexOf(contains, StringComparison.InvariantCultureIgnoreCase) < 0)
                Assert.Fail(String.Format("Expected exception {0} thrown, but message didn't contain \"{1}\".  Message: \"{2}\"", 
                            ex.GetType().FullName, contains, ex.Message));

            caught = true;
        }

        if (!caught)
            Assert.Fail(String.Format("Expected exception {0} not thrown"), typeof(T).FullName);
    }
}

some example calls:

private bool ThrowEx()
{
    throw new Exception();
}

private bool ThrowExContains()
{
    throw new NullReferenceException("a special message");
}

[Test]
public void TestExceptionWrapper()
{
    // .NET 3.5 style with lamba notation
    SpecHelpers.ExpectException<Exception>(() => ThrowEx());
    SpecHelpers.ExpectExceptionMessageContains<NullReferenceException>(() => ThrowExContains(), "special");

    // .NET 2.0 style with anonymous delegate
    SpecHelpers.ExpectExceptionMessageContains<NullReferenceException>(delegate() { ThrowExContains(); }, "special");
}

Share this post: Email it! | bookmark it! | digg it! | reddit!

Functional Programming and Unit Testing

alecl — Sat, 13 Sep 2008 17:21:00 GMT

These code samples are from:

http://www.ayende.com/Blog/archive/2008/06/06/Scratching-an-itch-NMemcached.aspx

   public class SystemTime
   {
       public static Func<DateTime> Now = () => DateTime.Now;
   }

At first I was wondering what the point of that was. Does he really hate the name DateTime? Was he planning on changing the class one day to not use DateTime.Now and wanted a layer of indirection? Turns out that was on the right track, but not exactly it.

https://rhino-tools.svn.sourceforge.net/svnroot/rhino-tools/experiments/NMemcached/NMemcached.Tests/Memcache_FlushAll_Tests.cs

After seeing his unit tests I figured it out. He changes the value of the static function SystemTime.Now from being a function call that is evaluated each time to returning a burned in value of January 1, 2000. Now his code that checks for the current time to see if something is expired will see that date. He tests this in "When_getting_item_that_has_been_expired_will_return_empty_result()". You could do something messier like adding a cache item that is set to expire in 2 seconds, sleeping 2 seconds, and then checking that it's gone, modifying your classes to allow passing in a DateTime or setting it via reflection, but this is so much neater and doesn't introduce delays into your unit tests which should run as fast as possible.

Share this post: Email it! | bookmark it! | digg it! | reddit!

Alec Lazarescu's Blog : Functional Programming, Unit Testing

Syntactic Sugar for Thrown Exception Checking with Generics

Functional Programming and Unit Testing