程序包 org.junit.rules

类 ExpectedException

  • 所有已实现的接口:
    TestRule
    public class ExpectedException
extends Object
implements TestRule
    The ExpectedException rule allows you to verify that your code throws a specific exception.

    Usage

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

     @Test
     public void throwsNothing() {
         // no exception expected, none thrown: passes.
     }

     @Test
     public void throwsExceptionWithSpecificType() {
         thrown.expect(NullPointerException.class);
         throw new NullPointerException();
     }
 }

    You have to add the ExpectedException rule to your test. This doesn't affect your existing tests (see throwsNothing()). After specifiying the type of the expected exception your test is successful when such an exception is thrown and it fails if a different or no exception is thrown.

    Instead of specifying the exception's type you can characterize the expected exception based on other criterias, too:

    You can combine any of the presented expect-methods. The test is successful if all specifications are met. 

     @Test
 public void throwsException() {
     thrown.expect(NullPointerException.class);
     thrown.expectMessage("happened");
     throw new NullPointerException("What happened?");
 }

    AssumptionViolatedExceptions

    JUnit uses AssumptionViolatedExceptions for indicating that a test provides no useful information. (See Assume for more information.) You have to call assume methods before you set expectations of the ExpectedException rule. In this case the rule will not handle consume the exceptions and it can be handled by the framework. E.g. the following test is ignored by JUnit's default runner. 

     @Test
 public void ignoredBecauseOfFailedAssumption() {
     assumeTrue(false); // throws AssumptionViolatedException
     thrown.expect(NullPointerException.class);
 }

    AssertionErrors

    JUnit uses AssertionErrors for indicating that a test is failing. You have to call assert methods before you set expectations of the ExpectedException rule, if they should be handled by the framework. E.g. the following test fails because of the assertTrue statement. 

     @Test
 public void throwsUnhandled() {
     assertTrue(false); // throws AssertionError
     thrown.expect(NullPointerException.class);
 }

    Missing Exceptions

    By default missing exceptions are reported with an error message like "Expected test to throw an instance of foo". You can configure a different message by means of reportMissingExceptionWithMessage(String). You can use a %s placeholder for the description of the expected exception. E.g. "Test doesn't throw %s." will fail with the error message "Test doesn't throw an instance of foo.".

    从以下版本开始:
    4.7

    • 方法详细资料

      • none

        public static ExpectedException none()
        Returns a rule that expects no exception to be thrown (identical to behavior without this rule).

      • reportMissingExceptionWithMessage

        public ExpectedException reportMissingExceptionWithMessage​(String message)
        Specifies the failure message for tests that are expected to throw an exception but do not throw any. You can use a %s placeholder for the description of the expected exception. E.g. "Test doesn't throw %s." will fail with the error message "Test doesn't throw an instance of foo.".
        参数:
        message - exception detail message
        返回:
        the rule itself

      • apply

        public Statement apply​(Statement base,
                       Description description)
        从接口复制的说明: TestRule
        Modifies the method-running Statement to implement this test-running rule.
        指定者:
        apply 在接口中 TestRule
        参数:
        base - The Statement to be modified
        description - A Description of the test implemented in base
        返回:
        a new statement, which may be the same as base, a wrapper around base, or a completely new Statement.

      • expect

        public void expect​(Matcher<?> matcher)
        Verify that your code throws an exception that is matched by a Hamcrest matcher. 
         @Test
 public void throwsExceptionThatCompliesWithMatcher() {
     NullPointerException e = new NullPointerException();
     thrown.expect(is(e));
     throw e;
 }

      • expect

        public void expect​(Class<? extends Throwable> type)
        Verify that your code throws an exception that is an instance of specific type. 
         @Test
 public void throwsExceptionWithSpecificType() {
     thrown.expect(NullPointerException.class);
     throw new NullPointerException();
 }

      • expectMessage

        public void expectMessage​(String substring)
        Verify that your code throws an exception whose message contains a specific text. 
         @Test
 public void throwsExceptionWhoseMessageContainsSpecificText() {
     thrown.expectMessage("happened");
     throw new NullPointerException("What happened?");
 }

      • expectMessage

        public void expectMessage​(Matcher<String> matcher)
        Verify that your code throws an exception whose message is matched by a Hamcrest matcher. 
         @Test
 public void throwsExceptionWhoseMessageCompliesWithMatcher() {
     thrown.expectMessage(startsWith("What"));
     throw new NullPointerException("What happened?");
 }

      • expectCause

        public void expectCause​(Matcher<? extends Throwable> expectedCause)
        Verify that your code throws an exception whose cause is matched by a Hamcrest matcher. 
         @Test
 public void throwsExceptionWhoseCauseCompliesWithMatcher() {
     NullPointerException expectedCause = new NullPointerException();
     thrown.expectCause(is(expectedCause));
     throw new IllegalArgumentException("What happened?", cause);
 }