@Before @BeforeClass @BeforeEach @BeforeAll

@Before vs @BeforeClass vs @BeforeEach vs @BeforeAll

Learn about the difference between JUnit annotations that can be used to run logic before tests.

1. Introduction

In this short tutorial, we're going to explain the differences between the @Before, @BeforeClass, @BeforeEach and @BeforeAll annotations in JUnit 4 and 5 – with practical examples of how to use them.

We'll also cover briefly their @After complementary annotations.

Let's start with JUnit 4.

2. @Before

Methods annotated with the @Before annotation are executed before each test. This is useful when we want to execute some common code before running a test.

Let's see an example where we initialize a list and add some values:

    @RunWith(JUnit4.class)
    public class BeforeAndAfterAnnotationsUnitTest {



        private List<String> list;

        @Before
        public void init() {
            LOG.info("startup");
            list = new ArrayList<>(Arrays.asList("test1", "test2"));
        }

        @After
        public void teardown() {
            LOG.info("teardown");
            list.clear();
        }
    }

Notice that we also added another method annotated with @After in order to clear the list after the execution of each test.

After that, let's add some tests to check the size of our list:

    @Test
    public void whenCheckingListSize_thenSizeEqualsToInit() {
        LOG.info("executing test");
        assertEquals(2, list.size());

        list.add("another test");
    }

    @Test
    public void whenCheckingListSizeAgain_thenSizeEqualsToInit() {
        LOG.info("executing another test");
        assertEquals(2, list.size());

        list.add("yet another test");
    }

In this case, it's crucial to make sure that test environment is properly set up before running each test since the list is modified during every test execution.

If we take a look at the log output we can check that the init and teardown methods were executed once per test:

... startup
... executing another test
... teardown
... startup
... executing test
... teardown

3. @BeforeClass

When we want to execute an expensive common operation before each test, it's preferable to execute it only once before running all tests using @BeforeClass. Some examples of common expensive operations are the creation of a database connection or the startup of a server.

Let's create a simple test class that simulates the creation of a database connection:

    @RunWith(JUnit4.class)
    public class BeforeClassAndAfterClassAnnotationsUnitTest {



        @BeforeClass
        public static void setup() {
            LOG.info("startup - creating DB connection");
        }

        @AfterClass
        public static void tearDown() {
            LOG.info("closing DB connection");
        }
    }

Notice that these methods have to be static, so they'll be executed before running the tests of the class.

As we did before, let's also add some simple tests:

    @Test
    public void simpleTest() {
        LOG.info("simple test");
    }

    @Test
    public void anotherSimpleTest() {
        LOG.info("another simple test");
    }

This time, if we take a look at the log output we can check that the setup and tearDown methods were executed only once:

... startup - creating DB connection
... simple test
... another simple test
... closing DB connection

4. @BeforeEach and @BeforeAll

@BeforeEac_h and @BeforeAll_ are the JUnit 5 equivalents of @Before and @BeforeClass. These annotations were renamed with clearer names to avoid confusion.

Let's duplicate our previous classes using these new annotations, starting with the @BeforeEach and @AfterEach annotations:

    @RunWith(JUnitPlatform.class)
    class BeforeEachAndAfterEachAnnotationsUnitTest {



        private List<String> list;

        @BeforeEach 
        void init() {
            LOG.info("startup");
            list = new ArrayList<>(Arrays.asList("test1", "test2"));
        }

        @AfterEach
        void teardown() {
            LOG.info("teardown");
            list.clear();
        }


    }

If we check logs, we can confirm that it works in the same way as with the @Before and @After annotations:

... startup
... executing another test
... teardown
... startup
... executing test
... teardown

Finally, let's do the same with the other test class to see the @BeforeAll and @AfterAll annotations in action:

    @RunWith(JUnitPlatform.class)
    public class BeforeAllAndAfterAllAnnotationsUnitTest {



        @BeforeAll
        public static void setup() {
            LOG.info("startup - creating DB connection");
        }

        @AfterAll
        public static void tearDown() {
            LOG.info("closing DB connection");
        }


    }

And the output is the same as with the old annotation:

... startup - creating DB connection
... simple test
... another simple test
... closing DB connection

5. Conclusion

In this article, we showed the differences between the @Before, @BeforeClass, @BeforeEach and @BeforeAll annotations in JUnit and when each of them should be used.

As always, the full source code of the examples is available over on GitHub.

---

Source