@ExtendWith annotation in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

The @ExtendWith annotation is used to register extensions in JUnit 5. Extensions add extra behavior to tests, like lifecycle callbacks or parameter injection.

intermediate

How do you apply multiple extensions using @ExtendWith?

You can apply multiple extensions by listing them inside @ExtendWith like this: @ExtendWith({Extension1.class, Extension2.class}).

beginner

True or False: @ExtendWith can only be used on test classes, not on individual test methods.

False. @ExtendWith can be used on both test classes and individual test methods to apply extensions at different scopes.

intermediate

What is a common use case for @ExtendWith in JUnit testing?

A common use case is to integrate third-party extensions like Mockito for mocking or to add custom behavior such as timing tests or managing resources.

advanced

Explain how @ExtendWith relates to JUnit 4's @RunWith annotation.

@ExtendWith in JUnit 5 replaces @RunWith from JUnit 4. It provides a more flexible way to add extensions compared to the older runner mechanism.

What does the @ExtendWith annotation do in JUnit 5?

A Marks a method as a test case

B Registers extensions to add behavior to tests

C Defines the order of test execution

D Skips a test method

@ExtendWith is used to register extensions that add extra behavior to tests, such as lifecycle callbacks or parameter injection.

How can you apply multiple extensions using @ExtendWith?

A By listing them in an array inside <code>@ExtendWith</code>

B By using multiple <code>@ExtendWith</code> annotations on the same class

C By calling extensions inside the test method

D By using <code>@RunWith</code> instead

You list multiple extensions inside curly braces like @ExtendWith({Ext1.class, Ext2.class}).

Can @ExtendWith be used on individual test methods?

A Only on interfaces

B No, only on classes

C Yes, it can be used on both classes and methods

D Only on constructors

@ExtendWith can be applied at class or method level to control extension scope.

Which JUnit 4 annotation is replaced by @ExtendWith in JUnit 5?

A <code>@RunWith</code>

B <code>@Test</code>

C <code>@Before</code>

D <code>@Ignore</code>

@ExtendWith replaces @RunWith to provide a more flexible extension mechanism.

Which of the following is NOT a typical use of @ExtendWith?

A Integrating third-party libraries like Mockito

B Adding custom test lifecycle behavior

C Injecting parameters into test methods

D Changing the test method's return type

@ExtendWith does not change method return types; it adds behavior or integrations.

Describe what the @ExtendWith annotation does and give an example of when you might use it.

Think about how you can add extra features to tests without changing test code.

Explain how @ExtendWith differs from JUnit 4's @RunWith annotation.

Consider flexibility and scope of application.

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