@EnumSource for enum values in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a JUnit test using @EnumSource with all enum values

What will be the output when running this JUnit 5 parameterized test using @EnumSource with all enum values?

JUnit

enum Color { RED, GREEN, BLUE }

@ParameterizedTest
@EnumSource(Color.class)
void testColors(Color color) {
    System.out.println(color);
}

A RED\nGREEN\nBLUE

B RED\nBLUE

C No output, test does not run

D GREEN\nBLUE

💡 Hint

The @EnumSource without filters runs the test once for each enum constant.

The @EnumSource(Color.class) runs the test method once for each enum constant in Color: RED, GREEN, and BLUE. Each call prints the enum name.

❓ assertion

intermediate

Correct assertion for filtered @EnumSource values

Given this enum and test, which assertion correctly verifies the test runs only for the filtered enum values?

JUnit

enum Status { SUCCESS, FAILURE, PENDING }

@ParameterizedTest
@EnumSource(value = Status.class, names = {"SUCCESS", "PENDING"})
void testStatus(Status status) {
    // assertion here
}

A assertTrue(status == Status.SUCCESS || status == Status.FAILURE || status == Status.PENDING);

B assertTrue(status == Status.SUCCESS || status == Status.PENDING);

C assertTrue(status == Status.FAILURE || status == Status.PENDING);

D assertTrue(status == Status.SUCCESS || status == Status.FAILURE);

💡 Hint

The test runs only for SUCCESS and PENDING, so assertion must check these two.

The @EnumSource filters to only SUCCESS and PENDING, so the status parameter will never be FAILURE. The assertion must check for SUCCESS or PENDING only.

🔧 Debug

advanced

Identify the error in @EnumSource usage

What error will occur when running this test code?

JUnit

enum Level { LOW, MEDIUM, HIGH }

@ParameterizedTest
@EnumSource(value = Level.class, names = {"LOW", "CRITICAL"})
void testLevel(Level level) {
    System.out.println(level);
}

A Compilation error due to invalid enum name

B Test runs only with LOW and ignores CRITICAL silently

C No error, prints LOW and CRITICAL

D java.lang.IllegalArgumentException: Enum constant CRITICAL not found

💡 Hint

Check if all names in the names array exist in the enum.

The enum Level does not have a constant named CRITICAL. Using a non-existent enum name in @EnumSource causes IllegalArgumentException at runtime.

🧠 Conceptual

advanced

Behavior of @EnumSource with mode EXCLUDE

What is the effect of using @EnumSource with mode = EnumSource.Mode.EXCLUDE and names = {"A", "B"} on an enum with constants A, B, C, D?

JUnit

enum Letter { A, B, C, D }

@ParameterizedTest
@EnumSource(value = Letter.class, mode = EnumSource.Mode.EXCLUDE, names = {"A", "B"})
void testLetter(Letter letter) {
    System.out.println(letter);
}

A The test runs with all constants A, B, C, D

B The test runs with A and B only, excluding C and D

C The test runs with C and D only, excluding A and B

D The test does not run due to invalid mode

💡 Hint

Mode.EXCLUDE removes the named constants from the test parameters.

Using mode = EXCLUDE with names {"A", "B"} excludes those constants from the test. The test runs only with C and D.

❓ framework

expert

Combining @EnumSource with custom argument conversion

Which code snippet correctly uses @EnumSource with a custom ArgumentConverter to convert enum values to lowercase strings for the test method parameter?

JUnit

enum Fruit { APPLE, BANANA, CHERRY }

public class LowercaseConverter implements ArgumentConverter {
    @Override
    public Object convert(Object source, ParameterContext context) {
        return ((Fruit) source).name().toLowerCase();
    }
}

@ParameterizedTest
@EnumSource(Fruit.class)
void testFruit(String fruitName) {
    System.out.println(fruitName);
}

A

@ParameterizedTest
@EnumSource(Fruit.class)
void testFruit(@ConvertWith(LowercaseConverter.class) String fruitName) { System.out.println(fruitName); }

B

@ParameterizedTest
@EnumSource(Fruit.class)
@ConvertWith(LowercaseConverter.class)
void testFruit(String fruitName) { System.out.println(fruitName); }

C

@ParameterizedTest
@EnumSource(Fruit.class)
void testFruit(String fruitName) { System.out.println(fruitName.toLowerCase()); }

D

@ParameterizedTest
@EnumSource(value = Fruit.class, mode = EnumSource.Mode.INCLUDE)
void testFruit(@ConvertWith(LowercaseConverter.class) Fruit fruit) { System.out.println(fruit); }

💡 Hint

The @ConvertWith annotation must be on the parameter, not the method.

To use a custom ArgumentConverter with @EnumSource, place @ConvertWith on the parameter to convert the enum to the desired type. Option A correctly applies @ConvertWith to the String parameter.