JUnit 4 如何在单次测试中多次验证同一异常抛出？

Great question! I’ve run into this exact issue with JUnit 4 before—when you have multiple edge cases that should all throw the same exception, the standard @Test(expected = ...) annotation falls flat because it bails out at the first exception it encounters. Here are a few practical, efficient ways to test all your 20 scenarios in a clean way:

1. Manual Try-Catch with a Loop #

This is the simplest approach if you don’t want to add extra dependencies or use specialized JUnit features. You can iterate over all your test inputs, wrap each method call in a try-catch block, and explicitly fail if any call doesn’t throw the expected exception.

import org.junit.Test;
import static org.junit.Assert.fail;
import java.util.Arrays;
import java.util.List;

public class FailureScenariosTest {
    private TestedObject testedObject = new TestedObject();

    @Test
    public void allInvalidInputsThrowException() {
        // List all your 20 test cases here
        List<String> invalidInputs = Arrays.asList("", null, "invalid-format", /* ... */);

        for (String input : invalidInputs) {
            try {
                testedObject.supposedToFail(input);
                // If we reach this line, no exception was thrown—mark as failure
                fail("Expected IllegalArgumentException for input: '" + input + "'");
            } catch (IllegalArgumentException e) {
                // Optional: Verify the exception message if needed
                // assertEquals("Input cannot be empty or null", e.getMessage());
            }
        }
    }
}

This way, every scenario is tested independently—even if one fails, the rest will still run, and you’ll get a clear message about which input didn’t behave as expected.

2. JUnit 4 Parameterized Tests #

If you want each scenario to show up as a separate entry in your test report (super helpful for debugging which case failed), parameterized tests are perfect. They let you define all your test data in one place, and JUnit will run the same test method for each input.

First, configure your test class to use the Parameterized runner:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Collection;

@RunWith(Parameterized.class)
public class ParameterizedFailureTest {
    private final String input;
    private TestedObject testedObject;

    // Constructor to receive each test input
    public ParameterizedFailureTest(String input) {
        this.input = input;
    }

    // Define all your 20 test cases here
    @Parameterized.Parameters
    public static Collection<Object[]> testData() {
        return Arrays.asList(new Object[][]{
                {""},
                {null},
                {"invalid-value"},
                // Add the remaining 17 scenarios
        });
    }

    @Before
    public void setUp() {
        testedObject = new TestedObject();
    }

    @Test(expected = IllegalArgumentException.class)
    public void invalidInputThrowsException() {
        testedObject.supposedToFail(input);
    }
}

Each input gets its own test execution, so you’ll see exactly which entry failed in your test results. No more duplicate test methods!

3. Use AssertJ for Cleaner Exception Assertions #

If your project already uses the AssertJ library (a popular alternative to JUnit’s built-in assertions), you can write more readable and flexible tests. AssertJ’s exception assertions let you verify each scenario without messy try-catch blocks.

import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;

public class AssertJFailureTest {
    private TestedObject testedObject = new TestedObject();

    @Test
    public void allInvalidInputsThrowException() {
        List<String> invalidInputs = Arrays.asList("", null, /* ... */);

        invalidInputs.forEach(input ->
                assertThatThrownBy(() -> testedObject.supposedToFail(input))
                        .isInstanceOf(IllegalArgumentException.class)
                        .hasMessageContaining("Invalid input") // Optional: Validate message
        );
    }
}

This approach is concise, readable, and each assertion runs independently—one failure won’t block the others.

Which to Choose? #

• If you want zero extra dependencies: Go with the manual try-catch loop.
• If you want clear, per-scenario test reports: Use parameterized tests.
• If you value readability and already use AssertJ: Stick with AssertJ’s assertions.

All three approaches will let you test all 20 scenarios efficiently without writing 20 separate test methods.

内容的提问来源于stack exchange，提问作者Yassine Badache