Custom display names for parameters in JUnit - Build an Automation Script

Verify custom display names for parameters in a parameterized JUnit test

Preconditions (2)

Step 1: Create a parameterized test method with multiple input values

Step 2: Use @ParameterizedTest and @ValueSource annotations

Step 3: Add @DisplayName and @DisplayNameGeneration annotations to customize display names

Step 4: Run the test suite

Step 5: Observe the test report or console output for custom display names of each parameterized test case

✅ Expected Result: Each parameterized test case should show the custom display name as defined by the annotations instead of default parameter values

Automation Requirements - JUnit 5

Assertions Needed:

Verify that the test method runs successfully for all parameters

Verify that the custom display names appear in the test report or console output

Best Practices:

Use @ParameterizedTest with appropriate source annotations like @ValueSource

Use @DisplayName to set a custom name for the test method

Use @DisplayNameGeneration or @DisplayName to customize parameter display names

Keep test methods simple and focused

Use assertions to verify expected behavior

Automated Solution

JUnit

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.DisplayNameGeneration;
import org.junit.jupiter.api.DisplayNameGenerator;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.assertTrue;

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
public class CustomDisplayNameTest {

    @ParameterizedTest(name = "Run {index}: input={0}")
    @ValueSource(strings = {"apple", "banana", "cherry"})
    @DisplayName("Test with custom display names for parameters")
    void testWithCustomDisplayNames(String fruit) {
        // Simple assertion to check input is not empty
        assertTrue(fruit.length() > 0);
    }
}

This test class uses JUnit 5 parameterized tests to run the testWithCustomDisplayNames method with three different string inputs.

The @ParameterizedTest annotation marks the method as parameterized. The name attribute customizes the display name for each parameterized invocation, showing the index and the input value.

The @ValueSource provides the input strings.

The @DisplayName annotation sets a custom name for the test method itself.

The class-level @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class) replaces underscores with spaces in method names, improving readability.

The assertion checks that the input string is not empty, a simple valid test.

When running this test, the test report or console output will show the custom display names like "Run 1: input=apple", "Run 2: input=banana", etc.

Common Mistakes - 3 Pitfalls

{'mistake': "Not using the 'name' attribute in @ParameterizedTest to customize parameter display names", 'why_bad': 'Without it, the test report shows default parameter values which may be unclear or hard to read', 'correct_approach': "Use the 'name' attribute in @ParameterizedTest to define a clear, descriptive display name pattern"}

{'mistake': 'Using @DisplayName on the parameterized test method without customizing individual parameter names', 'why_bad': 'The method name changes but individual parameter runs still show default values, causing inconsistent display names', 'correct_approach': "Combine @DisplayName for the method and 'name' attribute in @ParameterizedTest for parameter runs"}

Forgetting to import necessary JUnit 5 annotations and classes

Bonus Challenge

Now add data-driven testing with 3 different inputs using @CsvSource and customize display names for each input set

Show Hint

Practice

1. What is the main purpose of using custom display names for parameters in JUnit tests?

easy

A. To speed up test execution time

B. To make test results easier to understand by showing meaningful names

C. To automatically fix failing tests

D. To generate test data automatically

Solution

1. Step 1: Understand the role of display names

   Custom display names help testers and developers read test reports more clearly by showing descriptive names instead of default method names.

2. Step 2: Identify the benefit in test results

   Meaningful names improve readability and debugging, making it easier to know what each test case checks.

3. Final Answer:

   To make test results easier to understand by showing meaningful names -> Option B

4. Quick Check:

   Custom display names = clearer test reports [OK]

Hint: Custom names improve report clarity, not speed or fixing [OK]

Common Mistakes:

• Thinking display names speed up tests
• Assuming display names fix test failures
• Confusing display names with test data generation

2. Which annotation syntax correctly sets a custom display name pattern for a parameterized test in JUnit 5?

easy

A. @ParameterizedTest(name = "Test {index} with value {0}")

B. @TestDisplay(name = "Test {index} with value {0}")

C. @DisplayNamePattern("Test {index} with value {0}")

D. @TestName("Test {index} with value {0}")

Solution

1. Step 1: Recall the correct annotation for parameterized test names

   JUnit 5 uses @ParameterizedTest with the 'name' attribute to set custom display names for parameters.

2. Step 2: Verify syntax correctness

   @ParameterizedTest(name = "Test {index} with value {0}") is the correct syntax; other options are invalid annotations.

3. Final Answer:

   @ParameterizedTest(name = "Test {index} with value {0}") -> Option A

4. Quick Check:

   @ParameterizedTest(name=...) = correct syntax [OK]

Hint: Use @ParameterizedTest(name = "...") for custom parameter names [OK]

Common Mistakes:

• Using non-existent annotations like @TestDisplay
• Confusing @DisplayName with parameterized name attribute
• Misspelling annotation names

3. Given the following test code snippet, what will be the display name of the second test execution?

@ParameterizedTest(name = "Run {index}: input={0}")
@ValueSource(strings = {"apple", "banana"})
void testFruits(String fruit) { /* test code */ }

medium

A. Run 1: input=apple

B. Run 1: input=banana

C. Run 2: input=banana

D. Run 2: input=apple

Solution

1. Step 1: Understand the index and parameter mapping

   The index starts at 1 for the first parameter, so the second test run has index 2 and parameter "banana".

2. Step 2: Substitute values into the display name pattern

   Replacing {index} with 2 and {0} with "banana" gives "Run 2: input=banana".

3. Final Answer:

   Run 2: input=banana -> Option C

4. Quick Check:

   Index 2 + second value banana = Run 2: input=banana [OK]

Hint: Index starts at 1; match parameter order [OK]

Common Mistakes:

• Assuming index starts at 0
• Mixing parameter values between runs
• Confusing index with parameter value

4. Identify the error in this JUnit 5 parameterized test code that tries to set a custom display name:

@ParameterizedTest(name = "Test {index} - {0}")
@ValueSource(ints = {1, 2, 3})
void testNumbers(int number) {
    assertTrue(number > 0);
}

medium

A. There is no error; the code is correct

B. The annotation @ParameterizedTest does not support 'name' attribute

C. The placeholder {0} cannot be used for int parameters

D. The method parameter type int is invalid for @ValueSource

Solution

1. Step 1: Check if 'name' attribute is valid in @ParameterizedTest

   @ParameterizedTest supports the 'name' attribute to customize display names.

2. Step 2: Verify placeholders and parameter types

   {0} correctly refers to the first parameter, which can be an int from @ValueSource.

3. Step 3: Confirm method and annotation compatibility

   Using int parameter with @ValueSource(ints = {...}) is valid and assertTrue is a valid assertion.

4. Final Answer:

   There is no error; the code is correct -> Option A

5. Quick Check:

   Valid syntax and usage = no error [OK]

Hint: Check if syntax matches JUnit 5 docs exactly [OK]

Common Mistakes:

• Thinking {0} can't be used with primitive types
• Believing 'name' attribute is unsupported
• Confusing parameter types with annotation requirements

5. You want to create a parameterized test in JUnit 5 that shows the test index, parameter value, and a custom message "Check value" in the display name. Which of the following is the correct way to write the @ParameterizedTest annotation to achieve this?

hard

A. @ParameterizedTest(name = "{index} - {0} - Check value")

B. @ParameterizedTest(name = "Test {index}: {0} - Check value")

C. @ParameterizedTest(name = "Check value - {index} - {0}")

D. All of the following are correct

Solution

1. Step 1: Understand the 'name' attribute flexibility

   The 'name' attribute accepts any string with placeholders {index} and {0} to customize display names.

2. Step 2: Check each option's format

   The three provided formats all correctly use {index} and {0} with additional text to form valid display names.

3. Step 3: Confirm all options are valid

   Since all formats are syntactically correct and achieve the goal, all are acceptable.

4. Final Answer:

   All of the following are correct -> Option D

5. Quick Check:

   Any string with {index} and {0} works [OK]

Hint: Any string with {index} and {0} placeholders is valid [OK]

Common Mistakes:

• Thinking only one exact format is allowed
• Misplacing placeholders causing syntax errors
• Forgetting to include both {index} and {0}