您如何断言在JUnit 4测试中引发了某种异常？

@Test
public void testFooThrowsIndexOutOfBoundsException() {
  boolean thrown = false;

  try {
    foo.doStuff();
  } catch (IndexOutOfBoundsException e) {
    thrown = true;
  }

  assertTrue(thrown);
}

#1 楼

这取决于JUnit版本和使用的断言库。对于JUnit5和4.13，请参见答案https://stackoverflow.com/a/2935935/2986984

如果您使用assertJ或google-truth，请参阅答案https://stackoverflow.com/a/41019785/2986984


JUnit <= 4.12的原始答案是：

@Test(expected = IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {

    ArrayList emptyList = new ArrayList();
    Object o = emptyList.get(0);

}

尽管回答https://stackoverflow.com/a/31826781/2986984为JUnit <= 4.12提供了更多选项。

参考：


JUnit测试常见问题解答

#2 楼

编辑：现在已经发布了JUnit 5和JUnit 4.13，最好的选择是使用Assertions.assertThrows()（对于JUnit 5）和Assert.assertThrows()（对于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(expected=IndexOutOfBoundsException.class)好得多，因为如果在IndexOutOfBoundsException之前抛出foo.doStuff()，则测试将失败。
有关详细信息，请参见本文。

#3 楼

请小心使用预期的异常，因为它仅断言该方法引发了该异常，而不是测试中的特定代码行。

我倾向于将其用于测试参数验证，因为此类方法通常是非常简单但更复杂的测试可能会更好地配合使用：

try {
    methodThatShouldThrow();
    fail( "My method didn't throw when I expected it to" );
} catch (MyException expectedException) {
}

应用判断。

#4 楼

如前所述，在JUnit中有许多处理异常的方法。但是对于Java 8，还有另一个：使用Lambda表达式。使用Lambda表达式，我们可以实现如下语法：

@Test
public void verifiesTypeAndMessage() {
    assertThrown(new DummyService()::someMethod)
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Runtime exception occurred")
            .hasMessageStartingWith("Runtime")
            .hasMessageEndingWith("occurred")
            .hasMessageContaining("exception")
            .hasNoCause();
}

assertThrown接受一个功能接口，该接口的实例可以使用lambda表达式，方法引用或构造函数引用创建。 assertThrown接受该接口将期望并已准备好处理异常。

这是一种相对简单但功能强大的技术。

请参阅此博客文章，介绍该技术：http ：//blog.codeleak.pl/2014/07/junit-testing-exception-with-java-8-and-lambda-expressions.html

源代码可以在这里找到：https： //github.com/kolorobot/unit-testing-demo/tree/master/src/test/java/com/github/kolorobot/exceptions/java8

披露：我是博客的作者和项目。

#5 楼

在junit中，有四种测试异常的方法。

junit5.x



对于junit5.x，可以按以下方式使用assertThrows

@Test
public void testFooThrowsIndexOutOfBoundsException() {
    Throwable exception = assertThrows(IndexOutOfBoundsException.class, () -> foo.doStuff());
    assertEquals("expected messages", exception.getMessage());
}

junit4.x



对于junit4.x，请使用测试注解的可选'expected'属性

@Test(expected = IndexOutOfBoundsException.class)
public void testFooThrowsIndexOutOfBoundsException() {
    foo.doStuff();
}

对于junit4.x，请使用ExpectedException规则

public class XxxTest {
    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void testFooThrowsIndexOutOfBoundsException() {
        thrown.expect(IndexOutOfBoundsException.class)
        //you can test the exception message like
        thrown.expectMessage("expected messages");
        foo.doStuff();
    }
}

也可以使用经典在junit 3框架下广泛使用的try / catch方法

@Test
public void testFooThrowsIndexOutOfBoundsException() {
    try {
        foo.doStuff();
        fail("expected exception was not occured.");
    } catch(IndexOutOfBoundsException e) {
        //if execution reaches here, 
        //it indicates this exception was occured.
        //so we need not handle it.
    }
}

so


如果您喜欢junit 5，那么您应该喜欢第一种方法
当您只想测试异常类型时使用第二种方法
当您想进一步测试异常消息时使用前两种方法
有关详细信息，请阅读junit 3，然后选择第4个。


有关更多信息，请阅读此文档和junit5用户指南以获取详细信息。

#6 楼

tl; dr


后JDK8：使用AssertJ或自定义lambda来声明异常行为。
pre-JDK8：我将推荐旧的良好的try-catch块。 （不要忘记在fail()块之前添加一个catch断言）

不管是Junit 4还是JUnit5。

长话短说

可以自己编写一个try-catch块，也可以使用JUnit工具（@Test(expected = ...)或@Rule ExpectedException JUnit规则功能）。

但是这些方法并不那么优雅并且不能很好地混合明智地使用其他工具。而且，JUnit工具确实存在一些陷阱。



try-catch块必须围绕测试的行为编写该块并将断言写入catch块，这也许很好，但许多人发现这种风格打断了测试的阅读流程。另外，您需要在Assert.fail块的末尾编写一个try。否则，测试可能会遗漏断言的某一方面； PMD，findbugs或Sonar会发现此类问题。

@Test(expected = ...)功能很有趣，因为您可以编写更少的代码，然后编写此测试据说不容易出现编码错误。但是这种方法在某些领域是缺乏的。


如果测试需要检查异常的其他内容，例如原因或消息（好的异常消息非常重要，则有一个精确的异常类型可能还不够）。

方法中也期望值很高，这取决于测试代码的编写方式，然后测试代码的错误部分会引发异常，导致测试结果为假，我不确定PMD，findbug或Sonar是否会提示此类代码。

@Test(expected = WantedException.class)
public void call2_should_throw_a_WantedException__not_call1() {
    // init tested
    tested.call1(); // may throw a WantedException

    // call to be actually tested
    tested.call2(); // the call that is supposed to raise an exception
}

ExpectedException规则也是试图解决以前的警告，但由于使用了期望样式，因此使用起来有点尴尬，EasyMock用户非常了解这种样式。对于某些人来说可能很方便，但是如果您遵循行为驱动开发（BDD）或“安排行为声明”（AAA）原则，则ExpectedException规则将不适合那些写作风格。除此之外，它可能会遇到与@Test方式相同的问题，具体取决于放置期望的位置。

@Rule ExpectedException thrown = ExpectedException.none()

@Test
public void call2_should_throw_a_WantedException__not_call1() {
    // expectations
    thrown.expect(WantedException.class);
    thrown.expectMessage("boom");

    // init tested
    tested.call1(); // may throw a WantedException

    // call to be actually tested
    tested.call2(); // the call that is supposed to raise an exception
}

即使期望的异常也放置在测试语句之前，如果测试遵循BDD或AAA，则会中断您的阅读流程。

此外，请参阅ExpectedException作者JUnit上的此注释问题。 JUnit 4.13-beta-2甚至不赞成使用此机制：


拉取请求＃1519：不赞成ExpectedException

方法Assert.assertThrows提供了一种更好的验证异常的方法。此外，与其他规则（如TestWatcher）一起使用时，ExpectedException的使用容易出错，因为在这种情况下，规则的顺序很重要。



因此上述这些选项具有他们所有的警告，并显然无法避免编码错误。



我有一个项目在创建了这个看起来很有希望的答案之后才意识到，这是一个例外。

正如该项目的描述所言，它使程序员可以用流畅的代码编写捕获异常的代码，并为后者的断言提供此异常。您可以使用任何断言库，例如Hamcrest或AssertJ。

从主页获取的快速示例：

// given: an empty list
List myList = new ArrayList();

// when: we try to get the first element of the list
when(myList).get(1);

// then: we expect an IndexOutOfBoundsException
then(caughtException())
        .isInstanceOf(IndexOutOfBoundsException.class)
        .hasMessage("Index: 1, Size: 0") 
        .hasNoCause();

您可以看到该代码非常简单，您可以在特定的行上捕获异常，then API是将使用AssertJ API的别名（类似于使用assertThat(ex).hasNoCause()...）。在某些时候，该项目依赖于FEST-声明AssertJ的祖先。编辑：看来该项目正在酝酿对Java 8 Lambdas的支持。

当前，该库有两个缺点：在撰写本文时，值得注意的是，该库基于Mockito 1.x，因为它创建了一个测试对象的模型。在幕后。由于Mockito仍未更新，因此该库无法使用最终类或最终方法。即使它基于当前版本的Mockito 2，这也需要声明一个全局模拟制作器（inline-mock-maker），这可能不是您想要的，因为该模拟制作器具有与常规模拟制作器不同的缺点。 />它还需要另一个测试依赖项。

一旦库支持lambda，这些问题将不再适用。但是，该功能将由AssertJ工具集复制。

如果您不想使用catch-exception工具，请考虑所有因素，我将推荐try-catch的旧方法块，至少达到JDK7。对于JDK 8用户，您可能更喜欢使用AssertJ，因为它提供的不仅仅是断言异常。


使用JDK8，lambda进入了测试场景，事实证明它们是一个不错的选择。断言异常行为的有趣方式。 AssertJ已更新，以提供一个很好的流利API来断言异常行为。

并使用AssertJ进行了示例测试：

@Test
public void test_exception_approach_1() {
    ...
    assertThatExceptionOfType(IOException.class)
            .isThrownBy(() -> someBadIOOperation())
            .withMessage("boom!"); 
}

@Test
public void test_exception_approach_2() {
    ...
    assertThatThrownBy(() -> someBadIOOperation())
            .isInstanceOf(Exception.class)
            .hasMessageContaining("boom");
}

@Test
public void test_exception_approach_3() {
    ...
    // when
    Throwable thrown = catchThrowable(() -> someBadIOOperation());

    // then
    assertThat(thrown).isInstanceOf(Exception.class)
                      .hasMessageContaining("boom");
}

通过对JUnit 5的近乎完全的重写，断言已得到了一些改进，作为断言正确地声明异常的开箱即用的方式，它们可能很有趣。但是实际上断言API仍然有点差，assertThrows之外没有任何东西。

@Test
@DisplayName("throws EmptyStackException when peeked")
void throwsExceptionWhenPeeked() {
    Throwable t = assertThrows(EmptyStackException.class, () -> stack.peek());

    Assertions.assertEquals("...", t.getMessage());
}

您注意到assertEquals仍在返回void，因此不允许像AssertJ这样的链式断言。

如果您还记得的话名称与Matcher或Assert发生冲突，请准备好与Assertions发生相同的冲突。


我想得出一个结论，今天（2017-03-03）无论使用哪种测试框架（无论是否使用JUnit，AssertJ的易用性，可发现的API，快速的开发速度以及事实上的测试依赖性）都是使用JDK8的最佳解决方案。 ），即使以前的JDK感到笨拙，它们也应该依赖try-catch块。

这个答案是从另一个问题获得的，该问题的知名度不一样，我是同一位作者。

#7 楼

现在已经发布了JUnit 5和JUnit 4.13，最好的选择是使用Assertions.assertThrows()（对于JUnit 5）和Assert.assertThrows()（对于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中的代码得到了有用的异常消息不会引发异常，如果引发其他异常，则不会引发堆栈跟踪
简洁
让您的测试遵循Arrange-Act-Assert
您可以精确地指出您期望抛出的代码异常
您不需要在throws子句中列出预期的异常
您可以使用您选择的断言框架对捕获的异常进行断言

方法将添加到JUnit 4.13中的org.junit Assert。

#8 楼

怎么样：捕获一个非常普通的异常，确保它使它脱离catch块，然后断言该异常的类就是您期望的异常。如果a）异常的类型错误（例如，如果您改为使用Null指针），并且b）从未引发异常，则此断言将失败。

public void testFooThrowsIndexOutOfBoundsException() {
  Throwable e = null;

  try {
    foo.doStuff();
  } catch (Throwable ex) {
    e = ex;
  }

  assertTrue(e instanceof IndexOutOfBoundsException);
}

#9 楼

使用可以与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指令。

#10 楼

BDD样式解决方案：JUnit 4 +捕获异常+ AssertJ

import static com.googlecode.catchexception.apis.BDDCatchException.*;

@Test
public void testFooThrowsIndexOutOfBoundsException() {

    when(() -> foo.doStuff());

    then(caughtException()).isInstanceOf(IndexOutOfBoundsException.class);

}

依赖项

eu.codearte.catch-exception:catch-exception:2.0

#11 楼

更新：JUnit5对异常测试进行了改进：assertThrows。
以下示例来自：Junit 5用户指南

 @Test
void exceptionTesting() {
    Throwable exception = assertThrows(IllegalArgumentException.class, () -> 
    {
        throw new IllegalArgumentException("a message");
    });
    assertEquals("a message", exception.getMessage());
}

使用JUnit 4的原始答案。
有几种方法可以测试是否引发了异常。我还在文章中讨论了以下选项：如何使用JUnit编写出色的单元测试
设置expected参数@Test(expected = FileNotFoundException.class)。

@Test(expected = FileNotFoundException.class) 
public void testReadFile() { 
    myClass.readFile("test.txt");
}

使用try catch

public void testReadFile() { 
    try {
        myClass.readFile("test.txt");
        fail("Expected a FileNotFoundException to be thrown");
    } catch (FileNotFoundException e) {
        assertThat(e.getMessage(), is("The file test.txt does not exist!"));
    }
     
}

测试使用ExpectedException规则。

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

@Test
public void testReadFile() throws FileNotFoundException {
    
    thrown.expect(FileNotFoundException.class);
    thrown.expectMessage(startsWith("The file test.txt"));
    myClass.readFile("test.txt");
}

您可以在JUnit4 Wiki中了解有关异常测试和bad.robot的更多信息。robot-预期异常JUnit规则。

#12 楼

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

使用这个小帮手，您将编写

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

这比JUnit 4.7的ExpectedException规则要详细。
与skaffman提供的解决方案相比，您可以指定期望的代码行例外。希望对您有所帮助。

#13 楼

您也可以执行以下操作：

@Test
public void testFooThrowsIndexOutOfBoundsException() {
    try {
        foo.doStuff();
        assert false;
    } catch (IndexOutOfBoundsException e) {
        assert true;
    }
}

#14 楼

恕我直言，检查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(e.getMessage(), containsString("the message");可能更可取。

#15 楼

JUnit 5解决方案

@Test
void testFooThrowsIndexOutOfBoundsException() {    
  Throwable exception = expectThrows( IndexOutOfBoundsException.class, foo::doStuff );

  assertEquals( "some message", exception.getMessage() );
}

有关JUnit 5的更多信息，请访问http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions

#16 楼

我在Mkyong博客中找到的Junit 4最灵活，最优雅的答案。它使用try/catch注释具有@Rule的灵活性。我喜欢这种方法，因为您可以读取自定义异常的特定属性。

package com.mkyong;

import com.mkyong.examples.CustomerService;
import com.mkyong.examples.exception.NameNotFoundException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.hasProperty;

public class Exception3Test {

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

    @Test
    public void testNameNotFoundException() throws NameNotFoundException {

        //test specific type of exception
        thrown.expect(NameNotFoundException.class);

        //test message
        thrown.expectMessage(is("Name is empty!"));

        //test detail
        thrown.expect(hasProperty("errCode"));  //make sure getters n setters are defined.
        thrown.expect(hasProperty("errCode", is(666)));

        CustomerService cust = new CustomerService();
        cust.findByName("");

    }

}

#17 楼

我在这里尝试了许多方法，但是它们要么很复杂，要么根本无法满足我的要求。实际上，可以非常简单地编写辅助方法：

public class ExceptionAssertions {
    public static void assertException(BlastContainer blastContainer ) {
        boolean caughtException = false;
        try {
            blastContainer.test();
        } catch( Exception e ) {
            caughtException = true;
        }
        if( !caughtException ) {
            throw new AssertionFailedError("exception expected to be thrown, but was not");
        }
    }
    public static interface BlastContainer {
        public void test() throws Exception;
    }
}

像这样使用它：

assertException(new BlastContainer() {
    @Override
    public void test() throws Exception {
        doSomethingThatShouldExceptHere();
    }
});

零依赖性：无需mockito，无需powermock；并且在期末课程上也能正常工作。

#18 楼

Java 8解决方案

如果您希望使用以下解决方案：


使用Java 8 lambdas
不依赖于任何JUnit魔术
允许您在一个测试方法中检查多个异常
检查由您的测试方法中的一组特定行引发的异常，而不是整个测试方法中的任何未知行引发的异常
产生实际异常被抛出的对象，以便您可以进一步检查它。

这是我写的一个实用函数：

public final <T extends Throwable> T expectException( Class<T> exceptionClass, Runnable runnable )
{
    try
    {
        runnable.run();
    }
    catch( Throwable throwable )
    {
        if( throwable instanceof AssertionError && throwable.getCause() != null )
            throwable = throwable.getCause(); //allows "assert x != null : new IllegalArgumentException();"
        assert exceptionClass.isInstance( throwable ) : throwable; //exception of the wrong kind was thrown.
        assert throwable.getClass() == exceptionClass : throwable; //exception thrown was a subclass, but not the exact class, expected.
        @SuppressWarnings( "unchecked" )
        T result = (T)throwable;
        return result;
    }
    assert false; //expected exception was not thrown.
    return null; //to keep the compiler happy.
}

（摘自我的博客） ）

按以下方式使用：

@Test
public void testThrows()
{
    RuntimeException e = expectException( RuntimeException.class, () -> 
        {
            throw new RuntimeException( "fail!" );
        } );
    assert e.getMessage().equals( "fail!" );
}

#19 楼

JUnit对此具有内置支持，并带有“ expected”属性。

#20 楼

就我而言，我总是从db获取RuntimeException，但是消息有所不同。并且异常需要分别处理。这是我测试的方式：

@Test
public void testThrowsExceptionWhenWrongSku() {

    // Given
    String articleSimpleSku = "999-999";
    int amountOfTransactions = 1;
    Exception exception = null;

    // When
    try {
        createNInboundTransactionsForSku(amountOfTransactions, articleSimpleSku);
    } catch (RuntimeException e) {
        exception = e;
    }

    // Then
    shouldValidateThrowsExceptionWithMessage(exception, MESSAGE_NON_EXISTENT_SKU);
}

private void shouldValidateThrowsExceptionWithMessage(final Exception e, final String message) {
    assertNotNull(e);
    assertTrue(e.getMessage().contains(message));
}

#21 楼

只需制作一个可以关闭和打开的Matcher，就像这样：

public class ExceptionMatcher extends BaseMatcher<Throwable> {
    private boolean active = true;
    private Class<? extends Throwable> throwable;

    public ExceptionMatcher(Class<? extends Throwable> throwable) {
        this.throwable = throwable;
    }

    public void on() {
        this.active = true;
    }

    public void off() {
        this.active = false;
    }

    @Override
    public boolean matches(Object object) {
        return active && throwable.isAssignableFrom(object.getClass());
    }

    @Override
    public void describeTo(Description description) {
        description.appendText("not the covered exception type");
    }
}

要使用它：

添加public ExpectedException exception = ExpectedException.none();，
然后：

ExceptionMatcher exMatch = new ExceptionMatcher(MyException.class);
exception.expect(exMatch);
someObject.somethingThatThrowsMyException();
exMatch.off();

#22 楼

在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");
    }

}

#23 楼

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

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());
}

#24 楼

除了NamShubWriter所说的以外，请确保：


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

不要这样做：

@Rule    
public ExpectedException expectedException;

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

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

#25 楼

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

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表达式中使用final对象引用。
此解决方案允许继续测试断言，而不是期望使用@Test(expected = IndexOutOfBoundsException.class)解决方案在方法级别可访问。

#26 楼

我建议使用库assertj-core处理junit测试中的异常

在Java 8中，如下所示：

//given

//when
Throwable throwable = catchThrowable(() -> anyService.anyMethod(object));

//then
AnyException anyException = (AnyException) throwable;
assertThat(anyException.getMessage()).isEqualTo("........");
assertThat(exception.getCode()).isEqualTo(".......);

#27 楼

例如，您要为下面提到的代码片段编写Junit

public int divideByZeroDemo(int a,int b){

    return a/b;
}

public void exceptionWithMessage(String [] arr){

    throw new ArrayIndexOutOfBoundsException("Array is out of bound");
}

上面的代码是为了测试可能发生的一些未知异常，下面的代码是使用自定义消息声明某些异常。

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

private Demo demo;
@Before
public void setup(){

    demo=new Demo();
}
@Test(expected=ArithmeticException.class)
public void testIfItThrowsAnyException() {

    demo.divideByZeroDemo(5, 0);

}

@Test
public void testExceptionWithMessage(){


    exception.expectMessage("Array is out of bound");
    exception.expect(ArrayIndexOutOfBoundsException.class);
    demo.exceptionWithMessage(new String[]{"This","is","a","demo"});
}

#28 楼

    @Test(expectedException=IndexOutOfBoundsException.class) 
    public void  testFooThrowsIndexOutOfBoundsException() throws Exception {
         doThrow(IndexOutOfBoundsException.class).when(foo).doStuff();  
         try {
             foo.doStuff(); 
            } catch (IndexOutOfBoundsException e) {
                       assertEquals(IndexOutOfBoundsException .class, ex.getCause().getClass());
                      throw e;

               }

    }

这是检查方法是否抛出正确异常的另一种方法。

#29 楼

JUnit框架具有assertThrows()方法：

ArithmeticException exception = assertThrows(ArithmeticException.class, () ->
    calculator.divide(1, 0));
assertEquals("/ by zero", exception.getMessage());

对于JUnit 5，它在org.junit.jupiter.api.Assertions类中；对于
，对于JUnit 4.13，它在org.junit.Assert类中；
对于早期版本的JUnit 4：只需将org.junit.jupiter:junit-jupiter-api上的引用添加到您的项目中，您将从JUnit 5中获得运行良好的版本。

#30 楼

使用Java 8，您可以创建一种方法，该方法将要检查的代码和预期的异常作为参数：

private void expectException(Runnable r, Class<?> clazz) { 
    try {
      r.run();
      fail("Expected: " + clazz.getSimpleName() + " but not thrown");
    } catch (Exception e) {
      if (!clazz.isInstance(e)) fail("Expected: " + clazz.getSimpleName() + " but " + e.getClass().getSimpleName() + " found", e);
    }
  }

，然后在测试中：

expectException(() -> list.sublist(0, 2).get(2), IndexOutOfBoundsException.class);

优点：


不依赖任何库
本地化检查-更精确，并且如果需要，可以在一个测试中包含多个这样的断言
易于使用