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

Practice

1.

What is the main purpose of using @EnumSource in JUnit tests?

easy

A. To convert enum values to strings

B. To create a new enum type inside the test class

C. To skip tests for enum values

D. To run the test method once for each value of an enum automatically

Solution

1. Step 1: Understand the role of @EnumSource

   @EnumSource is an annotation in JUnit that provides enum values as parameters to a test method.

2. Step 2: Identify what it does in tests

   It runs the test method once for each enum constant, so all enum values are tested automatically.

3. Final Answer:

   To run the test method once for each value of an enum automatically -> Option D

4. Quick Check:

   @EnumSource runs tests per enum value = D [OK]

Hint: Remember: @EnumSource runs tests for every enum value [OK]

Common Mistakes:

• Thinking @EnumSource creates enums
• Believing it skips enum values
• Confusing it with string conversion

2.

Which of the following is the correct syntax to use @EnumSource for an enum named Status in a JUnit 5 parameterized test?

@ParameterizedTest
@EnumSource(??? )
void testStatus(Status status) { ... }

easy

A. @EnumSource(Status.class)

B. @EnumSource("Status")

C. @EnumSource(Status)

D. @EnumSource(enum = Status)

Solution

1. Step 1: Recall correct @EnumSource syntax

   The annotation requires the enum class name with .class, like Status.class.

2. Step 2: Check each option

   @EnumSource(Status.class) uses Status.class which is correct syntax. Others are invalid Java or annotation syntax.

3. Final Answer:

   @EnumSource(Status.class) -> Option A

4. Quick Check:

   Use enum class with .class in @EnumSource = A [OK]

Hint: Use EnumName.class inside @EnumSource parentheses [OK]

Common Mistakes:

• Omitting .class after enum name
• Using string instead of class reference
• Adding invalid parameters

3.

Given the enum Color { RED, GREEN, BLUE } and the test:

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

What will be the output when this test runs?

medium

A. BLUE GREEN RED

B. RED GREEN

C. RED GREEN BLUE

D. No output, test fails

Solution

1. Step 1: Understand @EnumSource behavior

   @EnumSource runs the test once for each enum constant in the order declared.

2. Step 2: Identify output from System.out.println

   Each test run prints the enum value. So output lines are RED, then GREEN, then BLUE.

3. Final Answer:

   RED GREEN BLUE -> Option C

4. Quick Check:

   Test runs once per enum value in order = C [OK]

Hint: Test runs once per enum value in declared order [OK]

Common Mistakes:

• Assuming only some enum values run
• Thinking output order is random
• Expecting test failure without reason

4.

Consider this test code snippet:

@ParameterizedTest
@EnumSource(Status.class)
void testStatus(String status) {
    assertNotNull(status);
}

What is the main problem here?

medium

A. The test method parameter type does not match the enum type

B. @EnumSource cannot be used with Status enum

C. assertNotNull is not a valid assertion

D. The test method must be static

Solution

1. Step 1: Check parameter type vs enum type

   @EnumSource(Status.class) passes enum constants of type Status, but method expects String parameter.

2. Step 2: Understand type mismatch impact

   This causes a runtime error because JUnit cannot convert Status enum to String automatically.

3. Final Answer:

   The test method parameter type does not match the enum type -> Option A

4. Quick Check:

   Parameter type must match enum type = A [OK]

Hint: Method parameter type must be the enum type used in @EnumSource [OK]

Common Mistakes:

• Using String instead of enum type as parameter
• Thinking @EnumSource only works with strings
• Assuming test method must be static

5.

You want to test only specific enum values OPEN and CLOSED from the enum TicketStatus { OPEN, IN_PROGRESS, CLOSED, REOPENED } using @EnumSource. Which is the correct way to do this?

hard

A. @EnumSource(TicketStatus.class, include = {OPEN, CLOSED})

B. @EnumSource(value = TicketStatus.class, names = {"OPEN", "CLOSED"})

C. @EnumSource(TicketStatus.class, only = {"OPEN", "CLOSED"})

D. @EnumSource(TicketStatus.class, filter = {OPEN, CLOSED})

Solution

1. Step 1: Recall how to filter enum values in @EnumSource

   @EnumSource supports a 'names' attribute to specify which enum constants to include.

2. Step 2: Check each option's syntax

   @EnumSource(value = TicketStatus.class, names = {"OPEN", "CLOSED"}) uses 'names' with string array correctly. Others use invalid or unsupported attributes.

3. Final Answer:

   @EnumSource(value = TicketStatus.class, names = {"OPEN", "CLOSED"}) -> Option B

4. Quick Check:

   Use 'names' to select enum values in @EnumSource = B [OK]

Hint: Use 'names' attribute with enum strings to filter values [OK]

Common Mistakes:

• Using unsupported attributes like include or only
• Passing enum constants instead of strings in names
• Forgetting to specify value = Enum.class