Why Checking exception type hierarchy in JUnit? - Purpose & Use Cases

The Big Idea

What if your tests could catch the exact error type every time without fail?

The Scenario

Imagine you have a big program that can throw many types of errors. You want to check if the program throws the right kind of error when something goes wrong. Doing this by running the program and watching for errors manually is like trying to catch a tiny fish with your bare hands in a big river.

The Problem

Manually checking errors is slow and easy to miss. You might see an error but not know if it is the exact type you expect or just a related one. This can cause confusion and bugs to slip through. Also, repeating these checks by hand every time you change code wastes a lot of time.

The Solution

Using JUnit to check exception type hierarchy lets you write clear tests that automatically verify if the thrown error is exactly the one you expect or a subtype. This saves time, reduces mistakes, and makes your tests reliable and easy to run again and again.

Before vs After

✗ Before

try {
  methodThatThrows();
  fail("Expected exception");
} catch (Exception e) {
  if (!(e instanceof SpecificException)) {
    fail("Wrong exception type");
  }
}

✓ After

assertThrows(SpecificException.class, () -> methodThatThrows());

What It Enables

You can confidently ensure your program throws the right errors, improving code quality and catching bugs early.

Real Life Example

When building a banking app, you want to check that withdrawing too much money throws an OverdraftException, not just any error. This test helps catch mistakes before customers see them.

Key Takeaways

Manual error checks are slow and error-prone.

JUnit's exception hierarchy checks automate and simplify this process.

This leads to more reliable and maintainable tests.