我想评论一下这个问题的解决方案，它避免了任何与异常相关的JUnit代码。

我使用assertTrue（布尔值）和try/catch组合来查找要抛出的预期异常。下面是一个示例：

public void testConstructor() {
    boolean expectedExceptionThrown;
    try {
        // Call constructor with bad arguments
        double a = 1;
        double b = 2;
        double c = a + b; // In my example, this is an invalid option for c
        new Triangle(a, b, c);
        expectedExceptionThrown = false; // because it successfully constructed the object
    }
    catch(IllegalArgumentException e) {
        expectedExceptionThrown = true; // because I'm in this catch block
    }
    catch(Exception e) {
        expectedExceptionThrown = false; // because it threw an exception but not the one expected
    }
    assertTrue(expectedExceptionThrown);
}

Junit4与Java8的解决方案是使用此功能：

public Throwable assertThrows(Class<? extends Throwable> expectedException, java.util.concurrent.Callable<?> funky) {
    try {
        funky.call();
    } catch (Throwable e) {
        if (expectedException.isInstance(e)) {
            return e;
        }
        throw new AssertionError(
                String.format("Expected [%s] to be thrown, but was [%s]", expectedException, e));
    }
    throw new AssertionError(
            String.format("Expected [%s] to be thrown, but nothing was thrown.", expectedException));
}

用法如下：

    assertThrows(ValidationException.class,
            () -> finalObject.checkSomething(null));

注意，唯一的限制是在lambda表达式中使用最终对象引用。此解决方案允许使用@test（expected=IndexOutOfBoundsException.class）解决方案继续测试断言，而不是期望在方法级别可以执行。

为了解决同样的问题，我设立了一个小项目：http://code.google.com/p/catch-exception/

使用这个小助手，您可以编写

verifyException(foo, IndexOutOfBoundsException.class).doStuff();

这比JUnit 4.7的ExpectedException规则更详细。与skaffman提供的解决方案相比，您可以指定期望在哪行代码中出现异常。我希望这有帮助。

JUnit 5解决方案

import static org.junit.jupiter.api.Assertions.assertThrows;

@Test
void testFooThrowsIndexOutOfBoundsException() {    
  IndexOutOfBoundsException exception = expectThrows(IndexOutOfBoundsException.class, foo::doStuff);
     
  assertEquals("some message", exception.getMessage());
}

关于JUnit 5的更多信息http://junit.org/junit5/docs/current/user-guide/#writing-测试断言

使用可以与JUnit一起使用的AssertJ断言：

import static org.assertj.core.api.Assertions.*;

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

  assertThatThrownBy(() -> foo.doStuff())
        .isInstanceOf(IndexOutOfBoundsException.class);
}

它比@Test（expected=IndexOutOfBoundsException.class）更好，因为它保证了测试中的预期行抛出了异常，并允许您更容易地检查有关异常的详细信息，例如消息：

assertThatThrownBy(() ->
       {
         throw new Exception("boom!");
       })
    .isInstanceOf(Exception.class)
    .hasMessageContaining("boom");

Maven/Gradle说明。

我想评论一下这个问题的解决方案，它避免了任何与异常相关的JUnit代码。

我使用assertTrue（布尔值）和try/catch组合来查找要抛出的预期异常。下面是一个示例：

public void testConstructor() {
    boolean expectedExceptionThrown;
    try {
        // Call constructor with bad arguments
        double a = 1;
        double b = 2;
        double c = a + b; // In my example, this is an invalid option for c
        new Triangle(a, b, c);
        expectedExceptionThrown = false; // because it successfully constructed the object
    }
    catch(IllegalArgumentException e) {
        expectedExceptionThrown = true; // because I'm in this catch block
    }
    catch(Exception e) {
        expectedExceptionThrown = false; // because it threw an exception but not the one expected
    }
    assertTrue(expectedExceptionThrown);
}