Execution order of lifecycle methods in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to annotate a method that runs once before all tests in a JUnit 5 test class.

JUnit

@[1]
static void setupAll() {
    System.out.println("Runs once before all tests");
}

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

ABeforeAll

BBeforeEach

CAfterAll

DAfterEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeEach instead of @BeforeAll

Forgetting to make the method static

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

2fill in blank

medium

Complete the code to annotate a method that runs before each test method in JUnit 5.

JUnit

@[1]
void setup() {
    System.out.println("Runs before each test");
}

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

ABeforeAll

BBeforeEach

CAfterAll

DAfterEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeAll instead of @BeforeEach

Making the method static (should be instance method)

The @BeforeEach annotation marks a method to run before each test method.

3fill in blank

hard

Fix the error in the code to correctly annotate a method that runs once after all tests in JUnit 5.

JUnit

@[1]
static void tearDownAll() {
    System.out.println("Runs once after all tests");
}

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

ABeforeAll

BAfterEach

CAfterAll

DBeforeEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using @AfterEach instead of @AfterAll

Not making the method static

The @AfterAll annotation marks a method to run once after all tests. The method must be static.

4fill in blank

hard

Fill both blanks to create a JUnit 5 test class with methods that run before all tests and after each test.

JUnit

import org.junit.jupiter.api.*;

public class ExampleTest {

    @[1]
    static void initAll() {
        System.out.println("Init before all tests");
    }

    @[2]
    void tearDown() {
        System.out.println("Cleanup after each test");
    }
}

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

ABeforeAll

BBeforeEach

CAfterEach

DAfterAll

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up @AfterEach and @AfterAll

Forgetting static on @BeforeAll method

@BeforeAll runs once before all tests, and @AfterEach runs after each test method.

5fill in blank

hard

Fill all three blanks to create a JUnit 5 test class with methods that run before each test, after each test, and once after all tests.

JUnit

import org.junit.jupiter.api.*;

public class LifecycleTest {

    @[1]
    void setup() {
        System.out.println("Before each test");
    }

    @[2]
    void cleanup() {
        System.out.println("After each test");
    }

    @[3]
    static void finish() {
        System.out.println("After all tests");
    }
}

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

ABeforeEach

BAfterEach

CAfterAll

DBeforeAll

Attempts:

3 left

💡 Hint

Common Mistakes

Using @BeforeAll instead of @BeforeEach for setup

Not making @AfterAll method static

@BeforeEach runs before each test, @AfterEach runs after each test, and @AfterAll runs once after all tests (method must be static).

Practice

1. In JUnit 5, which lifecycle method runs exactly once before any test methods in the class?

easy

A. @AfterAll

B. @BeforeEach

C. @AfterEach

D. @BeforeAll

Solution

1. Step 1: Understand lifecycle annotations

   @BeforeAll is designed to run once before all tests in the class.

2. Step 2: Compare with other annotations

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

3. Final Answer:

   @BeforeAll -> Option D

4. Quick Check:

   @BeforeAll runs once before all tests [OK]

Hint: Remember: All = once before all tests [OK]

Common Mistakes:

• Confusing @BeforeEach with @BeforeAll
• Thinking @AfterAll runs before tests
• Mixing up @AfterEach and @BeforeEach

2. Which of the following is the correct syntax to define a method that runs after each test in JUnit 5?

easy

A. @AfterEach
void cleanup() {}

B. @AfterAll
void cleanup() {}

C. @BeforeEach
void cleanup() {}

D. @BeforeAll
void cleanup() {}

Solution

1. Step 1: Identify the annotation for after each test

   @AfterEach is the annotation that runs a method after every test method.

2. Step 2: Check method syntax

   The method should be void and can have any name, here 'cleanup()' is valid.

3. Final Answer:

   @AfterEach void cleanup() {} -> Option A

4. Quick Check:

   @AfterEach runs after each test method [OK]

Hint: AfterEach means after every single test method [OK]

Common Mistakes:

• Using @AfterAll instead of @AfterEach
• Confusing @BeforeEach with @AfterEach
• Missing void return type

3. Consider the following JUnit 5 test class:

@BeforeAll
static void initAll() { System.out.println("InitAll"); }
@BeforeEach
void init() { System.out.println("Init"); }
@Test
void testOne() { System.out.println("TestOne"); }
@Test
void testTwo() { System.out.println("TestTwo"); }
@AfterEach
void tearDown() { System.out.println("TearDown"); }
@AfterAll
static void tearDownAll() { System.out.println("TearDownAll"); }

What is the correct order of printed lines when running this test class?

medium

A. InitAll, Init, TestOne, TearDown, Init, TestTwo, TearDown, TearDownAll

B. Init, InitAll, TestOne, TearDown, TestTwo, Init, TearDownAll

C. InitAll, Init, TestOne, Init, TestTwo, TearDown, TearDownAll, TearDown

D. InitAll, TestOne, Init, TearDown, Init, TestTwo, TearDown, TearDownAll

Solution

1. Step 1: Understand lifecycle method order

   @BeforeAll runs once before all tests, then for each test @BeforeEach runs, test runs, then @AfterEach runs. Finally, @AfterAll runs once after all tests.

2. Step 2: Apply to given methods

   Output order: InitAll (once), then for testOne: Init, TestOne, TearDown; for testTwo: Init, TestTwo, TearDown; finally TearDownAll.

3. Final Answer:

   InitAll, Init, TestOne, TearDown, Init, TestTwo, TearDown, TearDownAll -> Option A

4. Quick Check:

   BeforeAll once, BeforeEach-Test-AfterEach per test, AfterAll once [OK]

Hint: Remember: BeforeAll/AfterAll once, BeforeEach/AfterEach per test [OK]

Common Mistakes:

• Mixing order of BeforeAll and BeforeEach
• Forgetting AfterEach runs after each test
• Placing AfterAll before AfterEach

4. Given the following JUnit 5 test class snippet, identify the error:

@BeforeAll
void setupAll() { System.out.println("Setup all"); }
@Test
void testMethod() { System.out.println("Test"); }

What is the problem with this code?

medium

A. @BeforeAll method must return boolean.

B. @BeforeAll method must be static.

C. @BeforeAll method cannot have a body.

D. @BeforeAll method must be private.

Solution

1. Step 1: Recall @BeforeAll requirements

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

2. Step 2: Check method signature

   The method 'setupAll' is not static, which causes a runtime error or test failure.

3. Final Answer:

   @BeforeAll method must be static. -> Option B

4. Quick Check:

   @BeforeAll requires static method by default [OK]

Hint: @BeforeAll methods are static unless configured otherwise [OK]

Common Mistakes:

• Making @BeforeAll non-static without lifecycle config
• Assuming @BeforeAll can be private
• Thinking @BeforeAll must return a value

5. You want to open a database connection once before all tests and close it once after all tests in a JUnit 5 test class. You also want to reset some data before each test and clean up after each test. Which combination of lifecycle methods should you use?

hard

A. @BeforeAll for resetting data, @AfterAll for cleanup, @BeforeEach for opening connection, @AfterEach for closing connection

B. @BeforeEach for opening connection, @AfterEach for closing connection, @BeforeAll for resetting data, @AfterAll for cleanup

C. @BeforeAll for opening connection, @AfterAll for closing connection, @BeforeEach for resetting data, @AfterEach for cleanup

D. @BeforeEach for resetting data, @AfterEach for cleanup, @BeforeAll for opening connection, @AfterAll for closing connection

Solution

1. Step 1: Assign tasks to lifecycle methods

   Opening and closing the database connection should happen once, so use @BeforeAll and @AfterAll.

2. Step 2: Use per-test methods for data reset and cleanup

   Resetting data and cleaning up should happen before and after each test, so use @BeforeEach and @AfterEach.

3. Final Answer:

   @BeforeAll for opening connection, @AfterAll for closing connection, @BeforeEach for resetting data, @AfterEach for cleanup -> Option C

4. Quick Check:

   Once methods for setup/teardown, each methods for per-test tasks [OK]

Hint: Once = BeforeAll/AfterAll, each test = BeforeEach/AfterEach [OK]

Common Mistakes:

• Opening connection before each test unnecessarily
• Resetting data only once before all tests
• Closing connection after each test causing overhead