@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.

Practice

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

easy

A. To mark a method as a test case

B. To disable a test method temporarily

C. To register extensions that add extra behavior to tests

D. To specify the order of test execution

Solution

1. Step 1: Understand the role of @ExtendWith

   This annotation is used to register extensions that can add behavior before, after, or around tests.

2. Step 2: Compare with other annotations

   Other annotations like @Test mark test methods, but @ExtendWith is specifically for extensions.

3. Final Answer:

   To register extensions that add extra behavior to tests -> Option C

4. Quick Check:

   @ExtendWith = register extensions [OK]

Hint: Remember: @ExtendWith adds extra test behavior [OK]

Common Mistakes:

• Confusing @ExtendWith with @Test
• Thinking it disables tests
• Assuming it controls test order

2. Which of the following is the correct syntax to use @ExtendWith to register a custom extension named MyExtension.class on a test class?

easy

A. @ExtendWith(MyExtension.class) public class TestClass {}

B. @ExtendWith{MyExtension.class} public class TestClass {}

C. @ExtendWith[MyExtension.class] public class TestClass {}

D. @ExtendWith public class TestClass {}

Solution

1. Step 1: Recall correct annotation syntax

   Annotations use parentheses with class references, like @ExtendWith(MyExtension.class).

2. Step 2: Identify invalid syntax

   Curly braces, square brackets, or angle brackets are not valid for this annotation.

3. Final Answer:

   @ExtendWith(MyExtension.class) public class TestClass {} -> Option A

4. Quick Check:

   Annotation syntax uses parentheses () [OK]

Hint: Use parentheses () with class name for annotations [OK]

Common Mistakes:

• Using curly braces {} instead of parentheses
• Using square brackets [] or angle brackets <>
• Omitting .class after the class name

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

@ExtendWith(MyExtension.class)
public class SampleTest {
    @Test
    void testMethod() {
        System.out.println("Test running");
    }
}

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

medium

A. Before test

B. Test running\nBefore test

C. Test running

D. Before test\nTest running

Solution

1. Step 1: Understand extension behavior

   The MyExtension implements BeforeTestExecutionCallback, so it runs code before the test method.

2. Step 2: Trace output order

   First, "Before test" prints from the extension, then "Test running" prints from the test method.

3. Final Answer:

   Before test\nTest running -> Option D

4. Quick Check:

   Extension beforeTestExecution runs before test method [OK]

Hint: BeforeTestExecutionCallback runs before test method [OK]

Common Mistakes:

• Assuming extension runs after test
• Ignoring extension output
• Confusing output order

4. Identify the error in the following JUnit 5 test class using @ExtendWith:

@ExtendWith
public class FaultyTest {
    @Test
    void testSomething() {}
}

medium

A. @ExtendWith cannot be used on classes

B. @ExtendWith is missing the extension class argument

C. The test method must be static

D. The test method must return a value

Solution

1. Step 1: Check @ExtendWith usage

   The annotation requires specifying which extension class to use, e.g., @ExtendWith(MyExtension.class).

2. Step 2: Validate other options

   It is valid on classes, test methods do not need to be static or return values.

3. Final Answer:

   @ExtendWith is missing the extension class argument -> Option B

4. Quick Check:

   @ExtendWith needs extension class specified [OK]

Hint: Always specify extension class inside @ExtendWith() [OK]

Common Mistakes:

• Omitting the extension class argument
• Thinking @ExtendWith can't be on classes
• Believing test methods must be static

5. You want to reuse a setup logic that prints "Setup done" before each test method in multiple test classes. How should you apply @ExtendWith to achieve this cleanly?

hard

A. Create a custom extension class implementing BeforeEachCallback and annotate each test class with @ExtendWith(YourExtension.class)

B. Add a static method printing "Setup done" and call it manually in each test method

C. Use @BeforeAll annotation in each test class to print "Setup done"

D. Annotate each test method with @ExtendWith(YourExtension.class) instead of the class

Solution

1. Step 1: Identify reusable setup approach

   Implementing a custom extension with BeforeEachCallback allows running code before each test method.

2. Step 2: Apply @ExtendWith on test classes

   Annotating test classes with @ExtendWith(YourExtension.class) reuses the setup logic cleanly across classes.

3. Step 3: Evaluate other options

   Manually calling methods or using @BeforeAll is less reusable or runs only once per class. Annotating methods individually is repetitive.

4. Final Answer:

   Create a custom extension class implementing BeforeEachCallback and annotate each test class with @ExtendWith(YourExtension.class) -> Option A

5. Quick Check:

   Custom extension + @ExtendWith on class = reusable setup [OK]

Hint: Use custom extension + @ExtendWith on class for reusable setup [OK]

Common Mistakes:

• Calling setup manually in each test
• Using @BeforeAll for per-test setup
• Annotating each test method instead of class