除了NamShubWriter所说的，还要确保：

ExpectedException实例是公共的（相关问题）ExpectedException未在@Before方法中实例化。这篇文章清楚地解释了JUnit执行顺序的所有复杂性。

不要这样做：

@Rule    
public ExpectedException expectedException;

@Before
public void setup()
{
    expectedException = ExpectedException.none();
}

最后，这篇博客文章清楚地说明了如何断言抛出了某个异常。

在JUnit 4或更高版本中，您可以如下测试异常

@Rule
public ExpectedException exceptions = ExpectedException.none();

这提供了许多可以用来改进JUnit测试的特性。如果您看到下面的示例，我将测试异常的3个方面。

引发的异常类型异常消息异常的原因

public class MyTest {

    @Rule
    public ExpectedException exceptions = ExpectedException.none();

    ClassUnderTest classUnderTest;

    @Before
    public void setUp() throws Exception {
        classUnderTest = new ClassUnderTest();
    }

    @Test
    public void testAppleisSweetAndRed() throws Exception {

        exceptions.expect(Exception.class);
        exceptions.expectMessage("this is the exception message");
        exceptions.expectCause(Matchers.<Throwable>equalTo(exceptionCause));

        classUnderTest.methodUnderTest("param1", "param2");
    }

}

我们可以在必须返回异常的方法之后使用断言失败：

try{
   methodThatThrowMyException();
   Assert.fail("MyException is not thrown !");
} catch (final Exception exception) {
   // Verify if the thrown exception is instance of MyException, otherwise throws an assert failure
   assertTrue(exception instanceof MyException, "An exception other than MyException is thrown !");
   // In case of verifying the error message
   MyException myException = (MyException) exception;
   assertEquals("EXPECTED ERROR MESSAGE", myException.getMessage());
}

IMHO，在JUnit中检查异常的最佳方法是try/catch/fail/assert模式：

// this try block should be as small as possible,
// as you want to make sure you only catch exceptions from your code
try {
    sut.doThing();
    fail(); // fail if this does not throw any exception
} catch(MyException e) { // only catch the exception you expect,
                         // otherwise you may catch an exception for a dependency unexpectedly
    // a strong assertion on the message, 
    // in case the exception comes from anywhere an unexpected line of code,
    // especially important if your checking IllegalArgumentExceptions
    assertEquals("the message I get", e.getMessage()); 
}

assertTrue对某些人来说可能有点强，所以assertThat（例如getMessage（），containsString（“消息”）；可能更可取。

现在JUnit 5和JUnit 4.13已经发布，最好的选择是使用Assertions.assertThrows（）（针对JUnit 5）和Assertions.AssertThrow（）（对于JUnit 4.13）JUnit 5用户指南。

下面是一个验证抛出异常的示例，并使用Truth对异常消息进行断言：

public class FooTest {
  @Test
  public void doStuffThrowsIndexOutOfBoundsException() {
    Foo foo = new Foo();

    IndexOutOfBoundsException e = assertThrows(
        IndexOutOfBoundsException.class, foo::doStuff);

    assertThat(e).hasMessageThat().contains("woops!");
  }
}

与其他答案中的方法相比，优势在于：

内置于JUnit如果lambda中的代码没有引发异常，则会得到一个有用的异常消息；如果它引发了不同的异常，则将得到一个堆栈跟踪简明的允许您的测试遵循排列动作断言您可以精确地指示希望抛出异常的代码您不需要在throws子句中列出预期的异常您可以使用自己选择的断言框架对捕获的异常进行断言

编辑：现在JUnit 5和JUnit 4.13已经发布，最好的选择是使用Assertions.assertThrows（）（针对JUnit 5）和Assertions.AssertThrow（）（对于JUnit 4.13+）。有关详细信息，请参阅我的其他答案。

如果您尚未迁移到JUnit 5，但可以使用JUnit 4.7，则可以使用ExpectedException规则：

public class FooTest {
  @Rule
  public final ExpectedException exception = ExpectedException.none();

  @Test
  public void doStuffThrowsIndexOutOfBoundsException() {
    Foo foo = new Foo();

    exception.expect(IndexOutOfBoundsException.class);
    foo.doStuff();
  }
}

这比@Test（预期=IndexOutOfBoundsException.class）好得多，因为如果在foo.doStuff（）之前抛出IndexOutofBoundsExcept，测试将失败

有关详细信息，请参阅本文。