@ExtendWith annotation in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of @ExtendWith Annotation

What is the primary purpose of the @ExtendWith annotation in JUnit 5?

A To inject mock objects into test classes automatically

B To mark a test method as disabled temporarily

C To specify the order in which test methods should run

D To register extensions that add additional behavior to test classes or methods

💡 Hint

Think about how JUnit 5 allows adding extra features to tests beyond basic assertions.

The @ExtendWith annotation is used to register extensions in JUnit 5. Extensions can add extra behavior like lifecycle callbacks, parameter resolution, or conditional test execution.

❓ Predict Output

intermediate

Output of Test with Custom Extension

Given the following JUnit 5 test code using @ExtendWith, what will be printed when the test runs?

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.*;

class MyExtension implements BeforeTestExecutionCallback {
    @Override
    public void beforeTestExecution(ExtensionContext context) {
        System.out.println("Before test: " + context.getDisplayName());
    }
}

@ExtendWith(MyExtension.class)
class SampleTest {
    @Test
    void testMethod() {
        System.out.println("Inside test method");
    }
}

A

Before test: testMethod(SampleTest)
Inside test method

B

Inside test method
Before test: testMethod(SampleTest)

C No output printed

D Only Inside test method

💡 Hint

Consider when the beforeTestExecution callback runs relative to the test method.

The beforeTestExecution method runs just before the test method. So the extension prints its message first, then the test method prints its message.

❓ assertion

advanced

Correct Assertion for Extension Registration

Which assertion correctly verifies that a test class is registered with a specific extension using @ExtendWith in JUnit 5?

A assertTrue(testClass.isAnnotationPresent(ExtendWith.class))

B assertEquals(ExtendWith.class, testClass.getAnnotation(ExtendWith.class))

C assertNotNull(testClass.getAnnotation(ExtendWith.class))

D assertFalse(testClass.isAnnotationPresent(ExtendWith.class))

💡 Hint

Check how to verify if an annotation is present on a class.

The isAnnotationPresent method returns true if the annotation is present. This is the best way to assert that @ExtendWith is used.

🔧 Debug

advanced

Debugging Extension Not Invoked

A developer uses @ExtendWith(MyExtension.class) on a test class, but the extension's methods are never called during test execution. What is the most likely cause?

A The extension class is not public

B The test class is missing the <code>@Test</code> annotation on methods

C The extension class does not implement any JUnit 5 extension interfaces

D JUnit 5 does not support <code>@ExtendWith</code> on classes

💡 Hint

Think about what JUnit 5 requires for an extension to be recognized and invoked.

JUnit 5 calls extension methods only if the extension class implements one or more extension interfaces like BeforeTestExecutionCallback. Without implementing these, the extension has no effect.

❓ framework

expert

Combining Multiple Extensions with @ExtendWith

Consider a test class annotated with @ExtendWith({ExtA.class, ExtB.class}). Which statement about the order of extension callbacks is true?

A Extensions are invoked in reverse order, so ExtB callbacks run before ExtA callbacks

B Extensions are invoked in the order they appear in the annotation, so ExtA callbacks run before ExtB callbacks

C Extension invocation order is random and cannot be controlled

D JUnit 5 merges extensions and runs their callbacks simultaneously

💡 Hint

Think about how JUnit 5 processes multiple extensions declared together.

JUnit 5 invokes extension callbacks in the order they are declared in the @ExtendWith annotation. So ExtA runs before ExtB.