@BeforeAll method in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of @BeforeAll method execution order

Consider the following JUnit 5 test class. What will be the output when running this test suite?

JUnit

import org.junit.jupiter.api.*;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SampleTest {

    @BeforeAll
    void setup() {
        System.out.println("Setup before all tests");
    }

    @Test
    void testOne() {
        System.out.println("Test One");
    }

    @Test
    void testTwo() {
        System.out.println("Test Two");
    }
}

A

Test One
Setup before all tests
Test Two

B

Test One
Test Two
Setup before all tests

C

Setup before all tests
Test One
Test Two

D

Setup before all tests
Test Two
Test One

💡 Hint

Remember that @BeforeAll runs once before any test methods.

The method annotated with @BeforeAll runs once before all test methods in the class. Since the test instance lifecycle is PER_CLASS, the @BeforeAll method can be non-static and will run before any tests.

Therefore, the output starts with "Setup before all tests", followed by the test methods' outputs in the order they run.

❓ assertion

intermediate

Correct assertion to verify @BeforeAll initialization

Given a JUnit 5 test class with a static variable initialized in a @BeforeAll method, which assertion correctly verifies the variable is initialized before tests run?

JUnit

import org.junit.jupiter.api.*;

public class InitTest {
    static String sharedResource;

    @BeforeAll
    static void init() {
        sharedResource = "Ready";
    }

    @Test
    void testResource() {
        // Which assertion is correct here?
    }
}

A Assertions.assertFalse(sharedResource.equals("Ready"));

B Assertions.assertEquals("Ready", sharedResource);

C Assertions.assertTrue(sharedResource.isEmpty());

D Assertions.assertNull(sharedResource);

💡 Hint

The @BeforeAll method sets sharedResource to "Ready" before tests run.

The @BeforeAll method initializes sharedResource to "Ready" before any test runs. Therefore, the correct assertion in the test method is to check that sharedResource equals "Ready".

🔧 Debug

advanced

Identify the error with @BeforeAll method

What error will occur when running this JUnit 5 test class?

JUnit

import org.junit.jupiter.api.*;

public class ErrorTest {

    @BeforeAll
    void setup() {
        System.out.println("Setup");
    }

    @Test
    void test() {
        System.out.println("Test");
    }
}

A java.lang.IllegalStateException: Test instance lifecycle not supported

B No error, test runs successfully

C java.lang.NullPointerException at setup()

D java.lang.Exception: Method setup() should be static

💡 Hint

By default, @BeforeAll methods must be static unless using PER_CLASS lifecycle.

In JUnit 5, @BeforeAll methods must be static unless the test class is annotated with @TestInstance(TestInstance.Lifecycle.PER_CLASS). Here, the method is non-static and the class uses default lifecycle, so a runtime error occurs indicating the method should be static.

🧠 Conceptual

advanced

Purpose of @BeforeAll in test lifecycle

Which statement best describes the purpose of the @BeforeAll method in JUnit 5?

A @BeforeAll runs once before all tests to perform setup shared by all tests.

B @BeforeAll runs before each test method to reset test data.

C @BeforeAll runs after all tests to clean up resources.

D @BeforeAll runs only if a test fails to retry the test.

💡 Hint

Think about when shared setup should happen in a test class.

@BeforeAll is designed to run once before any test methods in the class. It is used to set up expensive or shared resources needed by all tests.

❓ framework

expert

Effect of @TestInstance on @BeforeAll method signature

How does annotating a JUnit 5 test class with @TestInstance(TestInstance.Lifecycle.PER_CLASS) affect the @BeforeAll method requirements?

A Allows @BeforeAll methods to be non-static because the test instance is shared.

B Requires @BeforeAll methods to be static regardless of lifecycle.

C Disables @BeforeAll methods entirely.

D Makes @BeforeAll methods run after each test method.

💡 Hint

Consider how test instance lifecycle affects method context.

When using @TestInstance(TestInstance.Lifecycle.PER_CLASS), JUnit creates a single test class instance for all tests. This allows @BeforeAll methods to be instance methods (non-static) because the same instance is used.