Core Java

Testing Expected Exceptions with JUnit Rules

This post shows how to test for expected exceptions using JUnit. Let’s start with the following class that we wish to test:

public class Person {
  private final String name;
  private final int age;

   * Creates a person with the specified name and age.
   * @param name the name
   * @param age the age
   * @throws IllegalArgumentException if the age is not greater than zero
  public Person(String name, int age) { = name;
    this.age = age;
    if (age <= 0) {
      throw new IllegalArgumentException('Invalid age:' + age);

In the example above, the Person constructor throws an IllegalArgumentException if the age of the person is not greater than zero. There are different ways to test this behaviour:

Approach 1: Use the ExpectedException Rule

This is my favourite approach. The ExpectedException rule allows you to specify, within your test, what exception you are expecting and even what the exception message is. This is shown below:

import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

public class PersonTest {

  public ExpectedException exception = ExpectedException.none();

  public void testExpectedException() {
    exception.expectMessage(containsString('Invalid age'));
    new Person('Joe', -1);

Approach 2: Specify the exception in the @Test annotation

As shown in the code snippet below, you can specify the expected exception in the @Test annotation. The test will pass only if an exception of the specified class is thrown by the test method. Unfortunately, you can’t test the exception message with this approach.

@Test(expected = IllegalArgumentException.class)
public void testExpectedException2() {
  new Person('Joe', -1);

Approach 3: Use a try-catch block

This is the ‘traditional’ approach which was used with old versions of JUnit, before the introduction of annotations and rules. Surround your code in a try-catch clause and test if the exception is thrown. Don’t forget to make the test fail if the exception is not thrown!

public void testExpectedException3() {
  try {
    new Person('Joe', -1);
    fail('Should have thrown an IllegalArgumentException because age is invalid!');
  } catch (IllegalArgumentException e) {
    assertThat(e.getMessage(), containsString('Invalid age'));


Reference: Testing Expected Exceptions with JUnit Rules from our JCG partner Fahd Shariff at the blog.

Fahd Shariff

Fahd is a software engineer working in the financial services industry. He is passionate about technology and specializes in Java application development in distributed environments.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Newest Most Voted
Inline Feedbacks
View all comments
Wesley Womack
Wesley Womack
11 years ago

Your link to the javadoc for ExpectedException returns a 404.

10 years ago

Am I missing something? Or are all the throws declarations are missing?

Matt Wharton
Matt Wharton
10 years ago
Reply to  Joel

The examples use IllegalArgumentException which is a RuntimeException and, therefore, does not need to be explicitly declared or surrounded in a try/catch as a checked exception (subclass of Exception) would be.

Back to top button