25.8. Common JUnit Annotations

JUnit provides several annotations that help define the lifecycle of test methods. These annotations allow developers to specify the setup, execution, and teardown processes around tests.

JUnit annotations are special markers that you place above a test method in Java. They indicate different instructions to the JUnit framework. For example, when you mark a method with @Test, it tells JUnit that this method should be executed as a test. Annotations also help manage resources by allowing setup to occur before each test runs and cleanup afterward.

Think of JUnit annotations like the instructions on a recipe card. Just like a recipe tells you when to mix ingredients, bake, or let things cool, JUnit annotations tell the framework how and when to run your tests.

@Test Marks a test method

The @Test annotation is used to declare a method as a test method. When JUnit runs, it looks for all methods annotated with @Test and executes them. This is the cornerstone of a unit test as it identifies which methods contain the test logic.

Consider @Test like a flag that you put on a specific task on a to-do list. When you see that flag, you know you have to perform that task — just like JUnit knows to run the method you’ve marked with @Test.

@BeforeEach Runs before each test method

The @BeforeEach annotation allows you to run a method before each test method in the class. This is useful for setting up any necessary objects or states that each test requires without duplicating code in each test method.

Imagine you're setting the table before each meal. Just as you need to lay the table every time you eat, using @BeforeEach ensures that every test has the same starting point with everything set up properly.

@AfterEach Runs after each test method

The @AfterEach annotation indicates that a certain method should run after each test method. This is typically used to clean up resources or reset the state after a test has run, ensuring that tests do not affect each other.

Think of @AfterEach like cleaning your desk after each study session. After every task, you tidy up so that your workspace is clear, ensuring that when you start the next task, there are no distractions from the last one.

@BeforeAll Runs once before all tests (static method)

The @BeforeAll annotation is used for a method that should run only once before any of the test methods in the class. This is often used for expensive setup processes that should not be repeated before each test, such as connecting to a database.

Consider @BeforeAll like a big project setup where you only build a framework or an environment once before starting all your work in it, rather than rebuilding the same setup for each individual task.

@AfterAll Runs once after all tests (static method)

The @AfterAll annotation performs the opposite of @BeforeAll and runs once after all test methods have been executed. It’s typically used for cleanup activities that only need to happen once, such as closing connections or freeing resources to prevent memory leaks.

Think of @AfterAll like sealing up a big project once you're finished with all the tasks. Once everything is done, you pack away your tools just once instead of putting them away after each small task.

@Disabled Skips a test method

The @Disabled annotation indicates that a test method should be skipped when running tests. This can be useful for temporarily ignoring tests while debugging or because they are not ready to be run.

Imagine deciding to skip a workout session. By marking it as @Disabled, you’re reserving the right to not include that activity in your routine until you choose to re-instate it later.

--