Custom extensions in JUnit - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to register a custom JUnit 5 extension using the @ExtendWith annotation.

JUnit

@ExtendWith([1].class)
public class MyTest {
    @Test
    void testSomething() {
        // test code
    }
}

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

AJUnitExtension

BTestExtension

CExtensionPoint

DMyExtension

Attempts:

3 left

💡 Hint

Common Mistakes

Using a class name that does not exist as an extension.

Forgetting to add .class after the extension class name.

The @ExtendWith annotation requires the class name of the custom extension. Here, 'MyExtension' is the correct custom extension class.

2fill in blank

medium

Complete the code to implement a custom JUnit 5 extension by overriding the beforeEach method.

JUnit

public class MyExtension implements BeforeEachCallback {
    @Override
    public void [1](ExtensionContext context) throws Exception {
        System.out.println("Before each test");
    }
}

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

AbeforeEach

BbeforeAll

CafterEach

DafterAll

Attempts:

3 left

💡 Hint

Common Mistakes

Using afterEach instead of beforeEach.

Using beforeAll which belongs to a different interface.

The BeforeEachCallback interface requires implementing the beforeEach method to run code before each test.

3fill in blank

hard

Fix the error in the custom extension code by completing the missing method name.

JUnit

public class MyExtension implements AfterTestExecutionCallback {
    @Override
    public void [1](ExtensionContext context) throws Exception {
        System.out.println("After test execution");
    }
}

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

AafterTestExecution

BafterAll

CafterEach

DbeforeTestExecution

Attempts:

3 left

💡 Hint

Common Mistakes

Using afterEach which belongs to a different interface.

Using beforeTestExecution which is not part of this interface.

The AfterTestExecutionCallback interface requires the method afterTestExecution to be implemented.

4fill in blank

hard

Fill both blanks to create a custom extension that implements both BeforeAllCallback and AfterAllCallback interfaces.

JUnit

public class MyExtension implements [1], [2] {
    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        System.out.println("Before all tests");
    }

    @Override
    public void afterAll(ExtensionContext context) throws Exception {
        System.out.println("After all tests");
    }
}

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

ABeforeAllCallback

BBeforeEachCallback

CAfterAllCallback

DAfterEachCallback

Attempts:

3 left

💡 Hint

Common Mistakes

Using BeforeEachCallback or AfterEachCallback which run before/after each test, not all tests.

Forgetting to implement both interfaces.

To run code before all tests and after all tests, implement BeforeAllCallback and AfterAllCallback interfaces.

5fill in blank

hard

Fill all three blanks to create a custom extension that logs test start and end times using BeforeTestExecutionCallback and AfterTestExecutionCallback.

JUnit

public class TimingExtension implements [1], [2] {
    private long startTime;

    @Override
    public void beforeTestExecution(ExtensionContext context) throws Exception {
        startTime = System.currentTimeMillis();
        System.out.println("Test started at: " + startTime);
    }

    @Override
    public void [3](ExtensionContext context) throws Exception {
        long endTime = System.currentTimeMillis();
        System.out.println("Test ended at: " + endTime);
        System.out.println("Duration: " + (endTime - startTime) + " ms");
    }
}

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

ABeforeTestExecutionCallback

BAfterTestExecutionCallback

CafterTestExecution

DbeforeTestExecution

Attempts:

3 left

💡 Hint

Common Mistakes

Using beforeTestExecution as the method name for after test execution.

Not implementing both interfaces.

The class implements BeforeTestExecutionCallback and AfterTestExecutionCallback interfaces. The method afterTestExecution is overridden to log the end time.

Practice

1. What is the main purpose of using a custom extension in JUnit with @ExtendWith?

easy

A. To generate test reports in different formats

B. To write test cases faster by skipping assertions

C. To change the Java version used by the test runner

D. To add reusable code that runs before or after tests automatically

Solution

1. Step 1: Understand the role of custom extensions

   Custom extensions allow adding reusable code that hooks into the test lifecycle, such as setup or teardown actions.

2. Step 2: Recognize the use of @ExtendWith

   The annotation @ExtendWith applies these extensions to tests so the extra code runs automatically before or after tests.

3. Final Answer:

   To add reusable code that runs before or after tests automatically -> Option D

4. Quick Check:

   Custom extensions = reusable lifecycle code [OK]

Hint: Remember @ExtendWith adds reusable code around tests [OK]

Common Mistakes:

• Thinking extensions skip assertions
• Confusing extensions with Java version settings
• Assuming extensions generate reports

2. Which of the following is the correct syntax to apply a custom extension class named MyExtension to a JUnit 5 test class?

easy

A. @ExtendWith(MyExtension.class)

B. @UseExtension(MyExtension)

C. @EnableExtension(MyExtension.class)

D. @ApplyExtension(MyExtension.class)

Solution

1. Step 1: Recall the correct annotation for extensions

   JUnit 5 uses @ExtendWith to apply extensions to test classes or methods.

2. Step 2: Check the syntax for specifying the extension class

   The extension class must be passed as a class literal with .class, so @ExtendWith(MyExtension.class) is correct.

3. Final Answer:

   @ExtendWith(MyExtension.class) -> Option A

4. Quick Check:

   @ExtendWith + .class = correct syntax [OK]

Hint: Use @ExtendWith with .class for extension classes [OK]

Common Mistakes:

• Omitting .class after the extension name
• Using wrong annotation names like @UseExtension
• Passing extension name without parentheses

3. Given the following extension code, what will be printed when the test runs?

public class PrintExtension implements BeforeEachCallback {
    @Override
    public void beforeEach(ExtensionContext context) {
        System.out.println("Before test: " + context.getDisplayName());
    }
}

@ExtendWith(PrintExtension.class)
public class SampleTest {
    @Test
    void testOne() {}
}

medium

A. Before test: testOne()

B. Before test: SampleTest

C. No output printed

D. Compilation error due to missing interface

Solution

1. Step 1: Understand BeforeEachCallback behavior

   The beforeEach method runs before each test method and prints the test's display name.

2. Step 2: Identify the display name for the test method

   The display name is the test method name with parentheses, so it prints "Before test: testOne()".

3. Final Answer:

   Before test: testOne() -> Option A

4. Quick Check:

   beforeEach prints test method name [OK]

Hint: BeforeEachCallback runs before each test method [OK]

Common Mistakes:

• Thinking it prints class name instead of method
• Assuming no output is printed
• Confusing interface implementation

4. Consider this extension implementation:

public class FaultyExtension implements BeforeEachCallback {
    @Override
    public void beforeEach(ExtensionContext context) {
        int x = 1 / 0;
    }
}

@ExtendWith(FaultyExtension.class)
public class TestClass {
    @Test
    void testMethod() {}
}

What will happen when running testMethod?

medium

A. The test will be skipped silently

B. The test will fail with an ArithmeticException before running

C. The test will pass normally

D. Compilation error due to division by zero

Solution

1. Step 1: Analyze the extension code for errors

   The extension's beforeEach method divides by zero, causing an ArithmeticException at runtime.

2. Step 2: Understand effect on test execution

   Since the exception occurs before the test runs, the test fails immediately with that exception.

3. Final Answer:

   The test will fail with an ArithmeticException before running -> Option B

4. Quick Check:

   Runtime error in extension causes test failure [OK]

Hint: Runtime errors in extensions fail tests before execution [OK]

Common Mistakes:

• Thinking division by zero causes compile error
• Assuming test passes despite extension error
• Believing test is skipped silently

5. You want to create a custom extension that sets up a database connection before all tests and closes it after all tests in a class. Which two JUnit 5 extension interfaces should you implement together?

hard

A. BeforeEachCallback and AfterEachCallback

B. TestInstancePostProcessor and ParameterResolver

C. BeforeAllCallback and AfterAllCallback

D. BeforeTestExecutionCallback and AfterTestExecutionCallback

Solution

1. Step 1: Identify lifecycle timing for setup/teardown

   Setting up before all tests and closing after all tests requires hooks that run once per test class, not per test method.

2. Step 2: Match interfaces to lifecycle events

   BeforeAllCallback runs before all tests in a class, and AfterAllCallback runs after all tests in a class, perfect for this use case.

3. Final Answer:

   BeforeAllCallback and AfterAllCallback -> Option C

4. Quick Check:

   BeforeAll + AfterAll = class-level setup/teardown [OK]

Hint: Use BeforeAllCallback and AfterAllCallback for class-level setup [OK]

Common Mistakes:

• Using BeforeEachCallback for class-level setup
• Confusing TestInstancePostProcessor with lifecycle callbacks
• Choosing test execution callbacks instead of all callbacks