Having trouble getting NUnit's Assert.Throws to work properly

I could have sworn that I've used NUnit's Assert.Throws to determine whether or not a particular exception gets thrown from a method, but my memory has failed me before. I read this post here on SO, but it didn't answer my question, as I know the correct syntax, and I don't want to do anything with the exception that gets returned (I don't want to look at the Exception's members, though this could be useful down the road).

I wrote unit tests to prove my lack of understanding in the use of Dictionary, and couldn't get it handle the KeyNotFoundException that gets thrown. Instead of NUn开发者_StackOverflow中文版it catching it and passing the test, I get an unhandled KeyNotFoundException error when I run. I verified that I don't have the VS IDE set up to break on thrown .NET exceptions.

I've tried this two ways:

Assert.Throws( typeof(KeyNotFoundException), () => value = prefs["doesn't exist"]);

and

Assert.Throws<KeyNotFoundException>( () => value = prefs["doesn't exist"]);

but both result in an unhandled exception. What am I missing here?

UPDATE seems like others can't reproduce this. Here's a screenshot:

This is an old thread, but try turning off Enable Just My Code in Visual Studio under Tools->Options. With that on, the debugger is trying to be helpful and stops at the last possible point within your code before the exception gets swallowed.

Or, at least that's my understanding of it.

If you turn off Enable Just My Code, the Assert.Throws should work correctly.

The debugger is stating that your exception is not being handled by user code, which is technically true. To demonstrate, I'll use the sample test sgreeve provided

[Test]
public void demonstrateThatExceptionThrown()
{
    string value;
    Dictionary<string, string> test = new Dictionary<string, string>();
    Assert.Throws(typeof(KeyNotFoundException), () => value = test["h"]);
}

When you execute it, you will receive a warning in VisualStudio that the exception is unhandled in user code. If you look at the callstack, you will see something like

[External Code]
CodeTests.DLL!CodeTests.MiscTests.demonstrateThatExceptionThrown.AnonymousMethod()
[External Code]
CodeTests.DLL!CodeTests.MiscTests.demonstrateThatExceptionThrown()
[External Code]

Because you have specified a delegate, the exception is happening within the "AnonymousMethod" that was created. This is being called by the .Net framework. The debugger is stopping because your delegate isn't handling the exception before it gets passed back to the framework. It doesn't care that further up the stack it might be handled in your code (perhaps since there is no way to guarantee that the external code will handle the exception correctly.)

To have VisualStudio see this as a handled exception, use the ExpectedException attribute and remove the delegate, like so:

[Test]
[ExpectedException(typeof(KeyNotFoundException))]
public void demonstrateThatExceptionThrown()
{
    string value;
    Dictionary<string, string> test = new Dictionary<string, string>();
    value = test["h"];
}

Not a direct answer, but I personally prefer to tag my tests with

[ExpectedException(typeof(KeyNotFoundException))]
public Test ShouldDoTheStuff() {

  ...

}

Does this work for you? I don't actually see anything wrong with your code per se.

EVEN MORE RECENTLY UPDATED ANSWER!

After our conversation in the comments added to this answer, I suspect that the nunitit test runner is the problem here. I don't believe there's anything wrong with your test as I have no problem executing it either using NUnit GUI or the excellent Resharper test runner.

UPDATED ANSWER

After seeing your screen shot, I tried stepping through my test with the debugger and saw exactly the same prompt about the unhandled exception. If I carry on stepping past that error, the test passes when I reach the end of the assertion.

When I run the test in none-debug mode using either the NUnit GUI or the Resharper 4.5 test runner, the test passes as expected every time.

Sorry to ask the obvious question, but what are you executing your test with? i.e. which test runner?

The exact code I've executed is:

using System;
using System.Collections.Generic;
using NUnit.Framework;

namespace ClassLibrary1
{
    [TestFixture]
    public class DictionaryTest
    {


        [Test]
        public void demonstrateThatExceptionThrown()
        {
            string value;
            Dictionary<string, string> test = new Dictionary<string, string>();
            Assert.Throws(typeof(KeyNotFoundException), () => value = test["h"]);
        }
    }
}