ParameterResolver extension in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of ParameterResolver supplying a String

What is the output of the following JUnit 5 test when using a ParameterResolver that always provides the string "Hello"?

JUnit

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

class HelloParameterResolver implements ParameterResolver {
    @Override
    public boolean supportsParameter(ParameterContext pc, ExtensionContext ec) {
        return pc.getParameter().getType() == String.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pc, ExtensionContext ec) {
        return "Hello";
    }
}

@ExtendWith(HelloParameterResolver.class)
public class GreetingTest {
    @Test
    void testGreeting(String greeting) {
        System.out.println(greeting);
    }
}

A null

B Test fails with ParameterResolutionException

C Compilation error

D Hello

💡 Hint

Think about what the ParameterResolver returns for the String parameter.

The ParameterResolver supports String parameters and returns "Hello". The test prints this value, so output is "Hello".

❓ assertion

intermediate

Assertion on injected parameter value

Given a ParameterResolver that injects an Integer with value 42, which assertion correctly verifies the injected value in a test method?

JUnit

import org.junit.jupiter.api.extension.*;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class IntParameterResolver implements ParameterResolver {
    @Override
    public boolean supportsParameter(ParameterContext pc, ExtensionContext ec) {
        return pc.getParameter().getType() == Integer.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pc, ExtensionContext ec) {
        return 42;
    }
}

@ExtendWith(IntParameterResolver.class)
public class NumberTest {
    @Test
    void testNumber(Integer number) {
        // Which assertion is correct here?
    }
}

A assertSame(42, number);

B assertTrue(number == 42);

C assertEquals(42, number);

D assertNotNull(number);

💡 Hint

Check which assertion compares values correctly for Integer objects.

assertEquals(42, number) correctly checks the Integer value. assertSame compares object references, which may fail due to boxing.

🔧 Debug

advanced

Why does ParameterResolver fail to inject?

Consider this ParameterResolver implementation that tries to inject a Double but the test method parameter is of type double (primitive). Why does the injection fail?

JUnit

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

class DoubleParameterResolver implements ParameterResolver {
    @Override
    public boolean supportsParameter(ParameterContext pc, ExtensionContext ec) {
        return pc.getParameter().getType() == Double.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pc, ExtensionContext ec) {
        return 3.14;
    }
}

@ExtendWith(DoubleParameterResolver.class)
public class PiTest {
    @Test
    void testPi(double value) {
        System.out.println(value);
    }
}

A supportsParameter returns false because double primitive != Double class

B resolveParameter returns wrong type causing ClassCastException

C Test method parameter must be Double, not double

D ParameterResolver interface is not implemented correctly

💡 Hint

Check the difference between primitive types and wrapper classes in Java.

supportsParameter checks for Double.class but the parameter is primitive double, so it returns false and injection fails.

🧠 Conceptual

advanced

ParameterResolver lifecycle and caching

Which statement about the lifecycle of a ParameterResolver instance in JUnit 5 is correct?

A ParameterResolver instances are created once per test class and reused

B ParameterResolver instances are singletons shared across all tests

C JUnit creates a new ParameterResolver instance per parameter injection

D A new ParameterResolver instance is created for each test method invocation

💡 Hint

Think about how JUnit 5 manages extensions and test instances.

ParameterResolver instances are created once per test class and reused across all test methods within that class.

❓ framework

expert

Custom ParameterResolver with conditional support

You want to create a ParameterResolver that only supports parameters annotated with @InjectValue and of type String. Which implementation of supportsParameter is correct?

JUnit

import org.junit.jupiter.api.extension.*;
import java.lang.reflect.Parameter;

@interface InjectValue {}

class ConditionalParameterResolver implements ParameterResolver {
    @Override
    public boolean supportsParameter(ParameterContext pc, ExtensionContext ec) {
        return pc.isAnnotated(InjectValue.class) && pc.getParameter().getType() == String.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pc, ExtensionContext ec) {
        return "Injected";
    }
}

A return pc.getParameter().getAnnotation(InjectValue.class) != null && pc.getParameter().getType().equals(String.class);

B return pc.isAnnotated(InjectValue.class) && pc.getParameter().getType() == String.class;

C return pc.getParameter().isAnnotationPresent(InjectValue.class) && pc.getParameter().getType() == String.class;

D return pc.isAnnotated(InjectValue.class) && pc.getParameter().getType().equals(String.class);

💡 Hint

Use ParameterContext methods to check annotation and type.

pc.isAnnotated checks for annotation presence correctly. Using == for Class comparison is valid. This option uses recommended API methods.