@BeforeAll method in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark the method to run once before all tests.

JUnit

public class CalculatorTest {

    [1]
    static void setup() {
        System.out.println("Setup before all tests");
    }

    @Test
    void testAdd() {
        // test code here
    }
}

Drag options to blanks, or click blank then click option'

A@BeforeEach

B@AfterAll

C@Test

D@BeforeAll

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeEach instead of @BeforeAll

Not making the method static when using @BeforeAll

The @BeforeAll annotation marks a method to run once before all tests in the class.

2fill in blank

medium

Complete the code to make the @BeforeAll method valid in JUnit 5.

JUnit

public class DatabaseTest {

    @BeforeAll
    [1] void init() {
        System.out.println("Initialize DB connection");
    }

    @Test
    void testQuery() {
        // test code
    }
}

Drag options to blanks, or click blank then click option'

Avoid

Bstatic

Cpublic void

Dprivate void

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting static keyword

Making method non-static without @TestInstance annotation

In JUnit 5, @BeforeAll methods must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS).

3fill in blank

hard

Fix the error in the @BeforeAll method declaration.

JUnit

public class ServiceTest {

    [1] void setup() {
        System.out.println("Setup service");
    }

    @Test
    void testService() {
        // test code
    }
}

Drag options to blanks, or click blank then click option'

A@BeforeAll static

B@BeforeEach void

C@BeforeAll void

D@AfterAll static void

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeAll without static

Using @BeforeEach instead of @BeforeAll

The @BeforeAll method must be static and annotated properly to run once before all tests.

4fill in blank

hard

Fill both blanks to correctly declare a @BeforeAll method with public access.

JUnit

public class ApiTest {

    @BeforeAll
    [1] [2] void setupAll() {
        System.out.println("API setup");
    }

    @Test
    void testApi() {
        // test code
    }
}

Drag options to blanks, or click blank then click option'

Apublic

Bstatic

Cvoid

Dprivate

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting static keyword

Using private access modifier

The method must be public and static to be a valid @BeforeAll method.

5fill in blank

hard

Fill all three blanks to create a valid @BeforeAll method that prints a message.

JUnit

public class UserTest {

    @BeforeAll
    [1] [2] void setup() {
        System.out.println([3]);
    }

    @Test
    void testUser() {
        // test code
    }
}

Drag options to blanks, or click blank then click option'

Astatic

Bvoid

C"Starting tests"

Dpublic

Attempts:

3 left

💡 Hint

Common Mistakes

Missing public or static keywords

Not using quotes around the print message

The method must be public static void and print the message string.

Practice

1. What is the main purpose of the @BeforeAll annotation in JUnit 5?

easy

A. To run a method once after all test methods

B. To run a method before each test method

C. To run a method after each test method

D. To run a method once before all test methods in the class

Solution

1. Step 1: Understand the role of @BeforeAll

   The @BeforeAll annotation marks a method to run once before any test methods in the class.

2. Step 2: Compare with other lifecycle annotations

   @BeforeEach runs before each test, @AfterEach runs after each test, and @AfterAll runs once after all tests.

3. Final Answer:

   To run a method once before all test methods in the class -> Option D

4. Quick Check:

   @BeforeAll = run once before all tests [OK]

Hint: Runs once before all tests, not before each [OK]

Common Mistakes:

• Confusing @BeforeAll with @BeforeEach
• Thinking it runs after tests
• Assuming it runs multiple times

2. Which of the following is the correct way to declare a @BeforeAll method in JUnit 5?

easy

A. public void setup() { ... }

B. private static void setup() { ... }

C. public static void setup() { ... }

D. void setup() { ... }

Solution

1. Step 1: Recall method requirements for @BeforeAll

   In JUnit 5, @BeforeAll methods must be static and public (or package-private) to run before all tests.

2. Step 2: Check each option's signature

   public void setup() { ... } is non-static, so invalid. private static void setup() { ... } is private, so invalid. void setup() { ... } is non-static and missing access modifier. public static void setup() { ... } is public static void, which is correct.

3. Final Answer:

   public static void setup() { ... } -> Option C

4. Quick Check:

   Static + public method = correct @BeforeAll signature [OK]

Hint: Must be static and public for @BeforeAll [OK]

Common Mistakes:

• Omitting static keyword
• Using private or protected access
• Missing void return type

3. Consider the following JUnit 5 test class snippet:

public class SampleTest {
    static int counter = 0;

    @BeforeAll
    public static void init() {
        counter = 5;
    }

    @Test
    public void testOne() {
        counter += 1;
        assertEquals(6, counter);
    }

    @Test
    public void testTwo() {
        counter += 2;
        assertEquals(7, counter);
    }
}

What will happen when these tests run?

medium

A. testOne passes, testTwo fails

B. Both tests pass

C. testOne fails, testTwo passes

D. Both tests fail

Solution

1. Step 1: Analyze @BeforeAll effect on counter

   The init() method sets counter = 5 once before all tests.

2. Step 2: Trace testOne execution

   testOne adds 1 to counter (5 + 1 = 6) and asserts 6, so it passes.

3. Step 3: Trace testTwo execution

   testTwo adds 2 to counter, but counter was modified by testOne and is now 6, so 6 + 2 = 8. It asserts 7, which fails.

4. Final Answer:

   testOne passes, testTwo fails -> Option A

5. Quick Check:

   Shared static state changes cause testTwo failure [OK]

Hint: Static state shared; second test sees changed value [OK]

Common Mistakes:

• Assuming counter resets before each test
• Ignoring static variable persistence
• Expecting both tests to pass

4. Given this JUnit 5 test class:

public class DemoTest {

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

    @Test
    public void testA() {
        assertTrue(true);
    }
}

What is the problem with this code?

medium

A. The @Test method must be static

B. The @BeforeAll method must be static

C. The @BeforeAll method cannot print output

D. The @BeforeAll method must return a value

Solution

1. Step 1: Check @BeforeAll method signature

   In JUnit 5, @BeforeAll methods must be static unless using a test instance lifecycle that allows non-static.

2. Step 2: Identify error in code

   The setup() method is non-static, which causes a runtime error or test failure.

3. Final Answer:

   The @BeforeAll method must be static -> Option B

4. Quick Check:

   @BeforeAll requires static method [OK]

Hint: Remember: @BeforeAll methods must be static [OK]

Common Mistakes:

• Making @BeforeAll method non-static
• Thinking @BeforeAll can return values
• Confusing @BeforeAll with @BeforeEach

5. You want to initialize a database connection once before all tests in a JUnit 5 test class. Which approach correctly uses @BeforeAll to achieve this, considering best practices?

hard

A. Use a static @BeforeAll method to open the connection and store it in a static variable

B. Use a non-static @BeforeAll method to open the connection

C. Open the connection inside each @Test method separately

D. Use @BeforeEach to open the connection before every test

Solution

1. Step 1: Understand @BeforeAll usage for shared setup

   @BeforeAll runs once before all tests, ideal for expensive setup like database connections.

2. Step 2: Apply static method and static variable for shared resource

   The method must be static, and the connection should be stored in a static variable to be accessible by all tests.

3. Step 3: Evaluate other options

   Use a non-static @BeforeAll method to open the connection is invalid because @BeforeAll must be static. Open the connection inside each @Test method separately and D open connection multiple times, which is inefficient.

4. Final Answer:

   Use a static @BeforeAll method to open the connection and store it in a static variable -> Option A

5. Quick Check:

   Static @BeforeAll + static resource = efficient shared setup [OK]

Hint: Static method + static variable for shared setup [OK]

Common Mistakes:

• Using non-static @BeforeAll method
• Opening connection multiple times unnecessarily
• Not storing connection in static variable